@hugpy/video-intelligence-ui 0.1.1 → 0.3.0

package/src/stations/GenerateStation.tsx

@@ -37,13 +37,16 @@ import {
   PromptFieldTabs,
   PromptListToolbar,
   STANDARD_NEGATIVE,
+  applyStandardNegative,
   composeNegative,
+  hasStandardNegative,
 } from "./studio/promptCard";
 // Movie's group "Generate prompts" rides the SAME one-call spread the Cinema
 // composer uses (usePromptAssist.runSpread + the pure builders/readers).
 import {
   buildSpreadBody,
   spreadNoticeLines,
+  type AssistMediaWire,
   type SpreadGoalInput,
 } from "../video/spreadAssist";
 import { StudioGenerateMode } from "./studio/StudioGenerateMode";
@@ -51,7 +54,7 @@ import { useIdentityProfiles, type IdentityProfile } from "./studio/useIdentityP
 import { GenIdentityBar, type BoundIdentity } from "./GenIdentityBar";
 import { useSidebarRegistry } from "./SidebarRegistry";
 import { useProjects } from "../video/useProjects";
-import { cancelJob } from "../video/jobTracker";
+import { cancelJob, trackJob, useJobTracker } from "../video/jobTracker";
 import { STILL_RUNNING_MESSAGE } from "./pollCaps";
 import { AddFileBar } from "./AddFileBar";
 import { useImageModels, useModelsByTask, requiredInputsFor } from "../video/useModels";
@@ -65,7 +68,6 @@ import { useMoviePresets } from "../video/useMoviePresets";
 import {
   addToLibrary,
   useMediaLibrary,
-  type LibraryItem,
 } from "../video/mediaLibrary";
 import {
   request,
@@ -87,7 +89,9 @@ import { registerComposer, type StageRequest } from "../video/composerBridge";
 import {
   mediaRefSchema,
   uploadResultSchema,
+  enqueueResultSchema,
   isMovieProgress,
+  type FrameExtractRequest,
   type GenPromptPart,
   type GenerateImageRequest,
   type GenerateSceneRequest,
@@ -233,7 +237,7 @@ type GoalRow = {
   // k92 — a movie goal IS a prompt component (same architecture as a Scene part):
   // it may carry its OWN generation knobs. Held as the same live strings the station
   // setters use so a goal's override parses/validates exactly like the shared value
-  // it defaults from. Empty = inherit the movie-level value (see goalKnobValues /
+  // it defaults from. Empty = falls back to the movie-level value (see goalKnobValues /
   // goalExtra). `knobs` = the 4 CondensedKnobStrip knobs (size/steps/guidance/seed);
   // `extra` = model + the goal-appropriate scene knobs (strength/chain/motion).
   knobs?: Partial<KnobValues>;
@@ -337,6 +341,14 @@ type PartEntry = {
   // Per-part PROMPT-ASSIST model (which text generator writes THIS prompt's
   // Enhance/Generate). Undefined = use the shared assist model / fleet default.
   assistModel?: string | null;
+  // k93 — per-card `negatives: [on/off]`: whether THIS card's Enhance/Generate
+  // also writes its Negative field. Undefined = on (today's behavior).
+  assistNegatives?: boolean;
+  // k93 — a frame PULLED from this part's attached video (the frame-extract
+  // job's output). The part keeps its video AND the frame; buildPartPromptParts
+  // emits the frame image BEFORE the video so the runner's image_paths[0] (the
+  // start frame) is the pulled still.
+  frame?: PartMedia;
 };
 // The share-tick keys for EVERY per-part setting. "share" = one value across all
 // prompts; unticked = each prompt keeps its own. (Scene owns its own share state
@@ -491,8 +503,15 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   // example prompt (matches the sample gens) so the brochure opens with a coherent,
   // runnable story instead of a blank composer. The seed string lives in src/demo/
   // and is injected ONLY behind isCanned() — the live path stays an empty prompt.
+  // k93: a new TEXT part opens with the standard negative VISIBLE in its Negative
+  // field (operator: standard negatives are the default) — explicit text, sent
+  // as-is; the std. tick reads its state from the field and can remove it.
   const [parts, setParts] = useSessionState<PartEntry[]>("gen.parts", () => [
-    { key: partKey(), text: isCanned() ? DEMO_GENERATE_PROMPT : "" },
+    {
+      key: partKey(),
+      text: isCanned() ? DEMO_GENERATE_PROMPT : "",
+      negative: STANDARD_NEGATIVE,
+    },
   ]);
   const [showImagePicker, setShowImagePicker] = useState<boolean>(false);
   const [showVideoPicker, setShowVideoPicker] = useState<boolean>(false);
@@ -563,25 +582,18 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   const [guidance, setGuidance] = useSessionState<string>("gen.guidance", DEFAULT_KNOBS.guidance);
   // blank = null (random)
   const [seed, setSeed] = useSessionState<string>("gen.seed", DEFAULT_KNOBS.seed);
-  // k89: no longer SEEDED with the standard-negative TEXT — the standard set now
-  // rides the [standard negative] checkbox (sceneStdNegative here for Scene; goal
-  // #1's stdNegative for Movie, seeded ON below) and is COMPOSED in at submit via
-  // composeNegative, so the effective default payload is byte-identical to the old
-  // prefill while the field itself opens empty. Presets/drafts still overwrite it.
+  // k89: no longer SEEDED with the standard-negative TEXT — for MOVIE the standard
+  // set rides goal #1's stdNegative tick (seeded ON below) and is COMPOSED in at
+  // submit via composeNegative. For SCENE (k93) this shared value is NOT read at
+  // all any more: each part sends exactly what its own visible Negative field
+  // holds (blank = blank, nothing implied); presets WRITE into part #1's field.
   const [negative, setNegative] = useSessionState<string>("gen.negative", "");
-  // Scene's [standard negative] tick — station-wide like `negative` itself (ONE
-  // negative per scene), rendered on part #1's tabbed Negative pane. Defaults ON to
-  // preserve the pre-k89 prefill behavior.
-  const [sceneStdNegative, setSceneStdNegative] = useSessionState<boolean>(
-    "gen.sceneStdNegative",
-    true,
-  );
 
   // ---- per-setting CARRY ticks on the base composer strip (operator ask
   // 2026-08-04, k63) ----
   // "Bring this setting into the post created component": every setting in the
   // condensed strip carries a tick, and the tick decides what a component SEEDED
-  // from this one inherits (today: a tester row via "+ Add row" / the per-model /
+  // from this one receives (today: a tester row via "+ Add row" / the per-model /
   // per-preset expanders; the same rule is what any future scene-carry flow reads).
   // Untick a setting and the new component gets the mode default instead — that is
   // how you build a sweep that varies exactly one thing. Purely client-side: no
@@ -672,7 +684,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   // and produces its OWN job (see useGenerateRowJobs); "Run all rows" fires them
   // together so the results land beside each other.
   //
-  // Rows deliberately do NOT get their own media. They inherit the base composer's
+  // Rows deliberately do NOT get their own media. They reuse the base composer's
   // image/video/identity parts, so a sweep holds the reference material fixed and
   // varies only the thing under test — otherwise the comparison proves nothing.
   const [testerOpen, setTesterOpen] = useState<boolean>(false);
@@ -693,6 +705,8 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   const [goals, setGoals] = useSessionState<GoalRow[]>("gen.movie.goals", () => [
     { id: goalKey(), start: "0", end: String(DEFAULT_GOAL_LEN), prompt: "", stdNegative: true },
   ]);
+  // Rows parked by lowering the goal count — revived (keys intact) when it grows.
+  const [goalStash, setGoalStash] = useSessionState<GoalRow[]>("gen.movie.goalStash", () => []);
   // When set, the image picker attaches its pick as THIS goal's reference (vs a part).
   const [goalAttachTarget, setGoalAttachTarget] = useState<string | null>(null);
   // ---- Movie prompt-list toolbar state (k88 — mirrors Cinema's group assist) ----
@@ -710,6 +724,64 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   const [sceneSelectedIds, setSceneSelectedIds] = useState<ReadonlySet<string>>(() => new Set());
   const [sceneSpreadNotice, setSceneSpreadNotice] = useState<string[] | null>(null);
   const [sceneSteeringSeed, setSceneSteeringSeed] = useState<number | null>(null);
+  // ---- k93 Scene group toolbar state ----
+  // `negatives: [on/off]` — when ON the group generate/enhance also write each
+  // selected part's Negative field (the old separate "Generate negative" button
+  // folded in here). Session-remembered like the other toolbar prefs.
+  const [sceneGroupNegatives, setSceneGroupNegatives] = useSessionState<boolean>(
+    "gen.sceneGroupNegatives",
+    true,
+  );
+  // The last EXPLICIT range (1-based, over text parts) — what "select all" goes
+  // back to when unticked. Null until the user has touched the range inputs /
+  // per-card ticks.
+  const sceneRangeMemo = useRef<{ start: number; end: number } | null>(null);
+  // The toolbar-level `[+ video]` PRETEXT: ONE video (library pick or upload)
+  // sent as context.media on the group generate/enhance so the backend describes
+  // it and feeds that description to the generator. Not a prompt part.
+  const [scenePretext, setScenePretext] = useState<PartMedia | null>(null);
+  const [scenePretextOpen, setScenePretextOpen] = useState<boolean>(false);
+  // Which card has its inline attach panel expanded (one at a time), and what.
+  const [partAttachOpen, setPartAttachOpen] = useState<
+    { key: string; kind: "image" | "video" | "library" } | null
+  >(null);
+  // Whether the inline `+ identity` expander is open per card key.
+  const [identityOpen, setIdentityOpen] = useState<ReadonlySet<string>>(() => new Set());
+  // Pull-frame: per part, the time (seconds, as typed) + the in-flight job id.
+  const [pullFrameAt, setPullFrameAt] = useState<Record<string, string>>({});
+  const [pullFrameJobs, setPullFrameJobs] = useState<Record<string, string>>({});
+  const [pullFrameError, setPullFrameError] = useState<Record<string, string>>({});
+  // Watch the tracker for the pull-frame jobs: on `done` the first output becomes
+  // this part's `frame` (the tracker has ALREADY pushed it into the library as
+  // "frames / frame 1"); on failure the message surfaces on the card.
+  const trackedJobs = useJobTracker();
+  useEffect(() => {
+    const entries = Object.entries(pullFrameJobs);
+    if (entries.length === 0) return;
+    for (const [key, jobId] of entries) {
+      const rec = trackedJobs.find((r) => r.jobId === jobId);
+      if (!rec) continue;
+      if (rec.status === "done") {
+        const out = rec.outputs[0];
+        setParts((prev) =>
+          prev.map((p) =>
+            p.key === key && out
+              ? { ...p, frame: { ref: out, origin: "frames", label: rec.label.replace(/^pull /, "") } }
+              : p,
+          ),
+        );
+        if (!out) setPullFrameError((prev) => ({ ...prev, [key]: "The job produced no frame." }));
+      } else if (rec.status === "failed" || rec.status === "cancelled" || rec.expired) {
+        setPullFrameError((prev) => ({ ...prev, [key]: rec.error ?? "Frame pull failed." }));
+      } else {
+        continue; // still running
+      }
+      setPullFrameJobs((prev) => {
+        const { [key]: _drop, ...rest } = prev;
+        return rest;
+      });
+    }
+  }, [trackedJobs, pullFrameJobs, setParts]);
   // ---- Director knobs (opt-in vision scoring / re-roll loop) ----
   const [visionEnabled, setVisionEnabled] = useSessionState<boolean>(
     "gen.visionEnabled",
@@ -823,7 +895,13 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
         // the prefilled text) — so the standard-set tick clears too, keeping the
         // effective payload identical to the old override semantics.
         setNegative(d.negative);
-        setSceneStdNegative(false);
+        // k93 (Scene): presets WRITE the negative into part #1's visible field —
+        // never a silent merge at submit. Replaces the whole field (override).
+        const presetNeg = d.negative;
+        setParts((prev) => {
+          const i = prev.findIndex((p) => !p.media);
+          return i < 0 ? prev : prev.map((p, j) => (j === i ? { ...p, negative: presetNeg } : p));
+        });
         setGoals((prev) =>
           prev.map((g, i) => (i === 0 ? { ...g, stdNegative: false } : g)),
         );
@@ -1201,7 +1279,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
 
   // ---- part mutations ----
   function addText() {
-    setParts((prev) => [...prev, { key: partKey(), text: "" }]);
+    setParts((prev) => [...prev, { key: partKey(), text: "", negative: STANDARD_NEGATIVE }]);
   }
   function editText(key: string, text: string) {
     setParts((prev) => prev.map((p) => (p.key === key ? { ...p, text } : p)));
@@ -1350,14 +1428,34 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
     );
   }
 
-  // Per-part Enhance/Generate — writes the prompt AND its negative (operator:
-  // the negative is part of the assist). The negative is derived from the NEW
-  // prompt (captured from runAssist's apply); Enhance refines the existing
+  // k93 §C (client half): the toolbar's `[+ video]` pretext as the typed
+  // `context.media` the assist routes accept — {uri, mime, label}. Undefined
+  // when nothing is attached so the body stays byte-identical to today.
+  function scenePretextWire(): AssistMediaWire | undefined {
+    if (!scenePretext) return undefined;
+    const media: AssistMediaWire = {
+      uri: scenePretext.ref.uri,
+      mime: scenePretext.ref.mime,
+    };
+    if (scenePretext.label) media.label = scenePretext.label;
+    return media;
+  }
+
+  // Per-part Enhance/Generate — writes the prompt AND (when this card's
+  // `negatives` toggle is on — default) its negative. The negative is derived from
+  // the NEW prompt (captured from runAssist's apply); Enhance refines the existing
   // negative, Generate writes a fresh one. Sequential because the assist hook
-  // allows one in-flight call at a time.
-  async function runPartAssist(p: PartEntry, mode: "detail" | "generate") {
+  // allows one in-flight call at a time. `opts.negatives` lets the GROUP enhance
+  // override the per-card toggle with the toolbar's; `opts.media` is the group
+  // pretext (k93 §C) — the per-card buttons pass none.
+  async function runPartAssist(
+    p: PartEntry,
+    mode: "detail" | "generate",
+    opts: { negatives?: boolean; media?: AssistMediaWire } = {},
+  ) {
     // This part's OWN assist model (falls back to the shared pick / fleet default).
     const model = p.assistModel ?? assist.assistModel ?? null;
+    const context = opts.media ? { media: opts.media } : undefined;
     let newText = p.text;
     await assist.runAssist(
       mode,
@@ -1366,32 +1464,28 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
         newText = t;
         editText(p.key, t);
       },
-      { model },
+      { model, ...(context ? { context } : {}) },
     );
     if (newText.trim() === "") return;
+    const writeNegative = opts.negatives ?? p.assistNegatives ?? true;
+    if (!writeNegative) return;
     await assist.runNegative(
       {
         subject: newText,
         draft: mode === "detail" ? p.negative ?? "" : "",
-        extra: { model },
+        extra: { model, ...(context ? { context } : {}) },
       },
-      // Fold the STANDARD negative into the generated one so the anti-frame terms
-      // are visibly IN the field (operator: standard negatives are default and part
-      // of Generate), not just appended silently at submit. Keep this part's std
-      // tick ON so it stays applied. composeNegative dedupes, so submit-time
-      // composition never doubles a term.
+      // k93: everything the wire will carry is IN the field. If the field held
+      // the standard set before this call, re-insert it (the std. tick stays
+      // honest — it reads the field); nothing is composed at submit.
       (neg) => {
-        const std = p.stdNegative ?? sceneStdNegative;
+        const std = hasStandardNegative(p.negative ?? "");
         // APPEND, never clobber (operator 2026-08-13): a GENERATED negative adds
         // to whatever the operator already typed (Enhance still refines-in-place —
         // its draft was the existing text, so appending would double it).
-        // composeNegative dedupes, so submit-time composition never doubles a term.
         const cur = (p.negative ?? "").trim().replace(/,\s*$/, "");
         const mergedRaw = mode === "generate" && cur ? `${cur}, ${neg}` : neg;
-        patchPart(p.key, {
-          negative: composeNegative(mergedRaw, std),
-          stdNegative: std,
-        });
+        patchPart(p.key, { negative: composeNegative(mergedRaw, std) });
       },
     );
     // NAME RIDES ALONG (operator 2026-08-13): derive the project name from the
@@ -1416,6 +1510,11 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
     const p = parts.find((x) => !x.media && x.text.trim() !== "");
     return p ? p.text : assembledPrompt;
   }
+  /** The base part's VISIBLE negative — a clone sends what its source shows (k93). */
+  function basePartNegative(): string {
+    const p = parts.find((x) => !x.media && x.text.trim() !== "") ?? parts.find((x) => !x.media);
+    return p?.negative ?? "";
+  }
   function addPartPerModel(): void {
     const text = basePromptText();
     if (text.trim() === "") return;
@@ -1434,6 +1533,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
       ...targets.map((m) => ({
         key: partKey(),
         text,
+        negative: basePartNegative(),
         extra: { model: m.id } as Partial<PartExtra>,
       })),
     ]);
@@ -1460,16 +1560,13 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
         const part: PartEntry = {
           key: partKey(),
           text,
+          negative: basePartNegative(),
           extra: { model: pre.model_key || modelId },
           knobs,
         };
-        // A preset's negative REPLACES the standard set (mirrors applyPresetLoad's
-        // setSceneStdNegative(false)) — otherwise the standard exclusions get
-        // appended and the component sends a different negative than the preset.
-        if (d.negative != null) {
-          part.negative = d.negative;
-          part.stdNegative = false;
-        }
+        // A preset's negative REPLACES the field outright (visible, sent as-is —
+        // k93: nothing is composed at submit).
+        if (d.negative != null) part.negative = d.negative;
         return part;
       }),
     ]);
@@ -1956,6 +2053,9 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   function buildPartPromptParts(p: PartEntry): GenPromptPart[] {
     const out: GenPromptPart[] = [];
     if (!p.media || p.text.trim() !== "") out.push({ kind: "text", text: p.text });
+    // k93: a frame pulled from the attached video rides as an IMAGE part placed
+    // before the video, so it is the start frame (image_paths[0]).
+    if (p.frame) out.push({ kind: "image", media: p.frame.ref });
     if (p.media)
       out.push(
         p.media.ref.kind === "video"
@@ -1997,10 +2097,8 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
 
   // Build ONE scene request from a component, or null when any resolved knob is
   // invalid (skip, never submit coerced garbage). `lead` = the shared media that
-  // conditions every prompt. Negative: the part's own value wins, else the shared
-  // station negative (so presets / the toolbar negative writer / the standard set
-  // still apply); the standard set composes in per the part's tick (default = the
-  // station's sceneStdNegative, i.e. ON).
+  // conditions every prompt. Negative (k93): EXACTLY what this part's visible
+  // Negative field holds — blank is blank; no shared fallback, nothing composed.
   function buildSceneRow(
     p: PartEntry,
     lead: GenPromptPart[],
@@ -2039,9 +2137,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
     const partNeedsImage =
       requiredInputsFor(partModel?.tasks ?? []).image === "required";
     if (partNeedsImage && !reqParts.some((x) => x.kind === "image")) return null;
-    const baseNeg = (p.negative ?? "").trim() || negative.trim();
-    const std = p.stdNegative ?? sceneStdNegative;
-    const neg = composeNegative(baseNeg, std).trim();
+    const neg = (p.negative ?? "").trim();
     return {
       rowId: p.key,
       req: {
@@ -2080,31 +2176,106 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
     setParts((prev) => prev.filter((p) => p.key !== key));
     if (attachTarget === key) setAttachTarget(null);
   }
-  /** Unpair a part's media, keeping its text (the part becomes a text part). */
+  /** Unpair a part's media (and any frame pulled from it), keeping its text. */
   function detachMedia(key: string) {
     setParts((prev) =>
-      prev.map((p) => (p.key === key ? { ...p, media: undefined } : p)),
+      prev.map((p) => (p.key === key ? { ...p, media: undefined, frame: undefined } : p)),
     );
   }
-  /** Open a picker in ATTACH mode: the selection pairs onto part `key`. */
-  function openAttachPicker(key: string, kind: "image" | "video") {
-    setAttachTarget(key);
-    setShowImagePicker(kind === "image");
-    setShowVideoPicker(kind === "video");
+  /** Drop only the pulled frame; the video stays attached. */
+  function detachFrame(key: string) {
+    setParts((prev) => prev.map((p) => (p.key === key ? { ...p, frame: undefined } : p)));
+  }
+  /**
+   * k93 §B.5: open the INLINE attach panel on card `key` (toggles closed when the
+   * same one is clicked again). image/video pair the pick onto this part
+   * (attachTarget routes the shared upload/ingest handlers here); "library" is
+   * the old "+ from library" APPEND path, rendered inline as well.
+   */
+  function openAttachPicker(key: string, kind: "image" | "video" | "library") {
+    const same = partAttachOpen?.key === key && partAttachOpen.kind === kind;
+    if (same) {
+      setPartAttachOpen(null);
+      setAttachTarget(null);
+      return;
+    }
+    setPartAttachOpen({ key, kind });
+    setAttachTarget(kind === "library" ? null : key);
+    // The station-level pickers are the APPEND path; the card owns attach now.
+    setShowImagePicker(false);
+    setShowVideoPicker(false);
   }
   // Route a picked media: pair it onto the attach-target part when one is set,
   // else append it as a new part (empty caption, editable in place).
   function placeMedia(media: PartMedia) {
+    setPartAttachOpen(null);
     if (attachTarget != null) {
       const target = attachTarget;
       setParts((prev) =>
-        prev.map((p) => (p.key === target ? { ...p, media } : p)),
+        prev.map((p) => (p.key === target ? { ...p, media, frame: undefined } : p)),
       );
       setAttachTarget(null);
       return;
     }
     setParts((prev) => [...prev, { key: partKey(), text: "", media }]);
   }
+
+  // ── k93 §B.6 pull-frame: ONE frame at `t` seconds out of this part's attached
+  // video, through the existing frame-extract job (station "frames", so the
+  // tracker's terminal push lands the frame in the library exactly like the
+  // Frames station does). A 0.25 s window at fps 4 yields exactly one frame, and
+  // max_frames: 1 keeps the backend's loud cap honest.
+  function pullFrame(p: PartEntry) {
+    if (!p.media || p.media.ref.kind !== "video") return;
+    const raw = (pullFrameAt[p.key] ?? "0").trim();
+    const t = toNumberOrNull(raw === "" ? "0" : raw);
+    const dur = p.media.ref.duration_s;
+    if (t == null || t < 0 || (dur != null && t >= dur)) {
+      setPullFrameError((prev) => ({
+        ...prev,
+        [p.key]: dur != null ? `Enter a time between 0 and ${dur.toFixed(2)} s.` : "Enter a time ≥ 0 s.",
+      }));
+      return;
+    }
+    setPullFrameError((prev) => {
+      const { [p.key]: _drop, ...rest } = prev;
+      return rest;
+    });
+    const req: FrameExtractRequest = {
+      source: p.media.ref,
+      fps: 4,
+      quality: 90,
+      fmt: "jpg",
+      window: { start_s: t, end_s: t + 0.25 },
+      max_frames: 1,
+    };
+    const enqueuedAt = Date.now();
+    void request<unknown>(hugpyConfig.frameExtractEnqueueUrl, {
+      method: "POST",
+      body: JSON.stringify(req),
+      headers: { "Content-Type": "application/json" },
+      meta: { specKey: "frames", operation: "frame_extract.enqueue" },
+    }).then((r) => {
+      if (!r.ok) {
+        setPullFrameError((prev) => ({ ...prev, [p.key]: describeAppError(errorOf(r)) }));
+        return;
+      }
+      const parsed = enqueueResultSchema.safeParse(okValue(r));
+      if (!parsed.success) {
+        setPullFrameError((prev) => ({ ...prev, [p.key]: "Malformed enqueue response." }));
+        return;
+      }
+      trackJob({
+        jobId: parsed.data.job_id,
+        kind: "frame_extract",
+        station: "frames",
+        rowKey: p.key,
+        label: `pull frame @ ${t}s`,
+        enqueuedAt,
+      });
+      setPullFrameJobs((prev) => ({ ...prev, [p.key]: parsed.data.job_id }));
+    });
+  }
   function movePart(key: string, dir: -1 | 1) {
     setParts((prev) => {
       const i = prev.findIndex((p) => p.key === key);
@@ -2622,27 +2793,32 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   }
 
   // ---- Movie prompt-list toolbar actions (k88 — the shared PromptListToolbar) ----
-  /** Cap + semantics mirror Cinema's Segments stepper: grow by appending default-
-      length windows after the last row, TRUNCATE from the tail to shrink. */
-  const MAX_MOVIE_GOALS = 24;
+  /** Semantics mirror Cinema's Segments stepper (2026-08-27): shrinking PARKS the
+      tail rows in a session stash instead of deleting them; growing revives parked
+      rows (keys intact) before appending default-length windows after the last
+      row. No upper cap. */
   function setGoalCount(n: number) {
-    if (!Number.isInteger(n) || n < 1 || n > MAX_MOVIE_GOALS) return;
-    setGoals((prev) => {
-      if (n === prev.length) return prev;
-      if (n < prev.length) return prev.slice(0, n);
-      const next = prev.slice();
-      while (next.length < n) {
-        const last = next[next.length - 1];
-        const start = last ? toNumberOrNull(last.end) ?? 0 : 0;
-        next.push({
-          id: goalKey(),
-          start: String(start),
-          end: String(start + DEFAULT_GOAL_LEN),
-          prompt: "",
-        });
-      }
-      return next;
-    });
+    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 next = [...goals, ...revived];
+    while (next.length < n) {
+      const last = next[next.length - 1];
+      const start = last ? toNumberOrNull(last.end) ?? 0 : 0;
+      next.push({
+        id: goalKey(),
+        start: String(start),
+        end: String(start + DEFAULT_GOAL_LEN),
+        prompt: "",
+      });
+    }
+    setGoals(next);
   }
   function toggleMovieSelected(id: string) {
     setMovieSelectedIds((prev) => {
@@ -2740,7 +2916,8 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
       if (n === prev.length) return prev;
       if (n > prev.length) {
         const next = prev.slice();
-        while (next.length < n) next.push({ key: partKey(), text: "" });
+        while (next.length < n)
+          next.push({ key: partKey(), text: "", negative: STANDARD_NEGATIVE });
         return next;
       }
       const next = prev.slice();
@@ -2758,14 +2935,6 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
       return next;
     });
   }
-  function toggleSceneSelected(key: string) {
-    setSceneSelectedIds((prev) => {
-      const next = new Set(prev);
-      if (next.has(key)) next.delete(key);
-      else next.add(key);
-      return next;
-    });
-  }
   // Selection is over TEXT parts only — the group actions rewrite prompts, and a
   // media part's caption rides as locked context (its checkbox renders disabled).
   // Live-row math, same as Movie: a removed part can leave a stale key behind.
@@ -2776,36 +2945,103 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   );
   const sceneAllSelected =
     sceneTextParts.length > 0 && sceneSelectedCount === sceneTextParts.length;
+  // k93 §A.1/2 — the RANGE view of the selection set (1-based over text parts):
+  // min/max of the ticked text parts, or null when nothing is ticked. The SET
+  // stays the source of truth; the range inputs, select-all and the per-card
+  // ticks all write into it.
+  const sceneSelectedIdx = sceneTextParts
+    .map((p, i) => (sceneSelectedIds.has(p.key) ? i + 1 : 0))
+    .filter((n) => n > 0);
+  const sceneRangeStart = sceneSelectedIdx.length ? Math.min(...sceneSelectedIdx) : null;
+  const sceneRangeEnd = sceneSelectedIdx.length ? Math.max(...sceneSelectedIdx) : null;
+  /** Select text parts #start … #end (1-based, inclusive, already clamped by the toolbar). */
+  function selectSceneRange(start: number, end: number) {
+    const s = Math.max(1, Math.min(start, sceneTextParts.length));
+    const e = Math.max(s, Math.min(end, sceneTextParts.length));
+    sceneRangeMemo.current = { start: s, end: e };
+    setSceneSelectedIds(new Set(sceneTextParts.slice(s - 1, e).map((p) => p.key)));
+  }
+  function toggleSceneSelected(key: string) {
+    setSceneSelectedIds((prev) => {
+      const next = new Set(prev);
+      if (next.has(key)) next.delete(key);
+      else next.add(key);
+      // A per-card tick un-checks select-all implicitly (the set is no longer
+      // every text part) and the range inputs show the new min/max; remember
+      // that span as the explicit range select-all returns to.
+      const idx = sceneTextParts
+        .map((p, i) => (next.has(p.key) ? i + 1 : 0))
+        .filter((n) => n > 0);
+      sceneRangeMemo.current = idx.length
+        ? { start: Math.min(...idx), end: Math.max(...idx) }
+        : null;
+      return next;
+    });
+  }
+  // select all: checked ⇒ #1 … #last; unchecked ⇒ back to the remembered
+  // explicit [start, end] (or nothing when no range was ever set).
   function toggleSceneSelectAll() {
-    setSceneSelectedIds(
-      sceneAllSelected ? new Set() : new Set(sceneTextParts.map((p) => p.key)),
-    );
+    if (sceneAllSelected) {
+      const memo = sceneRangeMemo.current;
+      if (memo && !(memo.start === 1 && memo.end === sceneTextParts.length)) {
+        selectSceneRange(memo.start, memo.end);
+      } else {
+        setSceneSelectedIds(new Set());
+      }
+      return;
+    }
+    if (sceneRangeStart != null && sceneRangeEnd != null) {
+      sceneRangeMemo.current = { start: sceneRangeStart, end: sceneRangeEnd };
+    }
+    setSceneSelectedIds(new Set(sceneTextParts.map((p) => p.key)));
+  }
+  // enhance (M selected): the selected text parts with a NON-BLANK prompt.
+  const sceneSelectedParts = sceneTextParts.filter((p) => sceneSelectedIds.has(p.key));
+  const sceneEnhanceCount = sceneSelectedParts.filter((p) => p.text.trim() !== "").length;
+  // The toolbar std. tick reads the FIELDS: checked iff every selected part's
+  // Negative already holds the standard set.
+  const sceneStdAllOn =
+    sceneSelectedParts.length > 0 &&
+    sceneSelectedParts.every((p) => hasStandardNegative(p.negative ?? ""));
+
+  // The scene's group-assist negative (k93): part #1's VISIBLE Negative field,
+  // explicitly — the first text part's field, sent as `global_negative` (its tab
+  // tooltip says so). No std composition, no shared fallback.
+  function sceneGroupNegative(): string {
+    return (sceneTextParts[0]?.negative ?? "").trim();
   }
 
-  // GROUP ACTION (k89): ONE coherent spread across the ticked text parts — the same
-  // one-call rule Cinema's onSpreadSelected / Movie's onMovieSpreadSelected enforce:
-  // selected parts are targets, everything else (unticked text, media captions)
-  // rides as LOCKED context, and the reply may only land on parts whose key came back.
+  // GROUP ACTION (k89/k93): ONE coherent spread across the ticked text parts — the
+  // same one-call rule Cinema's onSpreadSelected / Movie's onMovieSpreadSelected
+  // enforce: selected parts are targets, everything else (unticked text, media
+  // captions) rides as LOCKED context, and the reply may only land on parts whose
+  // key came back. With `negatives: on` the returned per-part negative is WRITTEN
+  // into that part's visible Negative field (the old separate "Generate negative"
+  // button folded in); off ⇒ prompts only. context.media carries the `[+ video]`
+  // pretext (§C) when one is attached.
   async function onSceneSpreadSelected() {
-    const wiredNegative = composeNegative(negative, sceneStdNegative);
+    const wiredNegative = sceneGroupNegative();
     const inputs: SpreadGoalInput[] = parts.map((p, i) => ({
       key: p.key,
       prompt: p.text,
-      negative: i === 0 ? wiredNegative : "",
+      negative: p.negative ?? "",
       seed: "",
       branchFrame: "",
       joint: "still",
       index: i,
     }));
+    const media = scenePretextWire();
     const body = buildSpreadBody({
       goals: inputs,
       selectedKeys: sceneSelectedIds,
       movieQuery: "",
       globalNegative: wiredNegative,
       steeringSeed: sceneSteeringSeed,
+      context: { kind: "scene", ...(media ? { media } : {}) },
     });
     if (!body) return;
     setSceneSpreadNotice(null);
+    const writeNegatives = sceneGroupNegatives;
     const res = await assist.runSpread(body);
     if (!res) return;
     const bySeg = new Map(res.segments.map((s) => [s.segment_id, s]));
@@ -2818,33 +3054,47 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
         // may linger in the select set — never overwrite a media caption).
         if (!sceneSelectedIds.has(p.key) || p.media) return p;
         const hit = bySeg.get(p.key);
-        // ONE scene negative on the wire — a returned per-part negative is dropped
-        // here rather than written somewhere it could never be sent (Movie's rule).
-        return hit ? { ...p, text: hit.prompt } : p;
+        if (!hit) return p;
+        if (!writeNegatives || hit.negative.trim() === "") return { ...p, text: hit.prompt };
+        // Keep the standard set if the field held it (the std. tick reads the field).
+        const std = hasStandardNegative(p.negative ?? "");
+        return { ...p, text: hit.prompt, negative: composeNegative(hit.negative, std) };
       }),
     );
     if (res.steering_seed != null) setSceneSteeringSeed(res.steering_seed);
     setSceneSpreadNotice(spreadNoticeLines(res, applied));
   }
 
-  // GROUP ACTION (k89): write the scene's ONE wired negative from the ticked parts'
-  // text — Movie's single-runNegative approach, not Cinema's per-row loop (the wire
-  // carries one negative per scene).
-  async function onSceneNegativesSelected() {
-    const rows = parts.filter((p) => sceneSelectedIds.has(p.key) && !p.media);
+  // GROUP ACTION (k93 §A.5): enhance (M selected) — the "detail" assist over every
+  // selected text part with a non-blank prompt. The spread endpoint carries no
+  // mode, so this runs SEQUENTIALLY per part through runPartAssist (one in-flight
+  // assist at a time — the hook's guard), each call carrying the toolbar's
+  // negatives toggle and the `[+ video]` pretext.
+  async function onSceneEnhanceSelected() {
+    const rows = sceneSelectedParts.filter((p) => p.text.trim() !== "");
     if (rows.length === 0) return;
     setSceneSpreadNotice(null);
-    const subject = rows
-      .map((p) => p.text.trim())
-      .filter((t) => t !== "")
-      .join("; ");
-    await assist.runNegative({ subject, draft: negative }, setNegative);
+    const media = scenePretextWire();
+    for (const p of rows) {
+      await runPartAssist(p, "detail", { negatives: sceneGroupNegatives, media });
+    }
   }
 
-  // Toolbar [standard negatives]: ONE wired negative (part #1's Negative tab), so
-  // this ticks that pane's [standard negative] on.
-  function onSceneStandardNegatives() {
-    setSceneStdNegative(true);
+  // Toolbar `[ ] std.` (k93 §A.4): tick ⇒ INSERT the standard set into every
+  // selected part's Negative field (deduped, comma-joined); untick ⇒ remove
+  // exactly those terms. Visible in the field — nothing composed at submit.
+  function onSceneStdChange(on: boolean) {
+    setParts((prev) =>
+      prev.map((p) =>
+        sceneSelectedIds.has(p.key) && !p.media
+          ? { ...p, negative: applyStandardNegative(p.negative ?? "", on) }
+          : p,
+      ),
+    );
+  }
+  /** Per-card std. tick (k93 §B.3): same explicit insert/remove on this part only. */
+  function onPartStdChange(p: PartEntry, on: boolean) {
+    patchPart(p.key, { negative: applyStandardNegative(p.negative ?? "", on) });
   }
   // Route a picked image: onto the attach-target GOAL (Movie mode) when set, else
   // through the parts placeMedia path (Image/Scene). Keeps the picker/upload code
@@ -2859,18 +3109,18 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
     placeMedia(media);
   }
 
-  function addImage(item: LibraryItem) {
-    placePickedImage({ ref: item.ref, origin: item.origin, label: item.label });
+  function addImageMedia(media: PartMedia) {
+    placePickedImage(media);
     setShowImagePicker(false);
   }
-  function addVideoFromLibrary(item: LibraryItem) {
-    placeMedia({ ref: item.ref, origin: item.origin, label: item.label });
+  function addVideoMedia(media: PartMedia) {
+    placeMedia(media);
     setShowVideoPicker(false);
   }
 
   // Upload a raw video, ingest it into a MediaRef, guard kind==="video", then
   // append it as a video part (and add it to the library so it is reusable).
-  async function onPickVideo(file: File) {
+  async function onPickVideo(file: File, place: (media: PartMedia) => void = placeMedia) {
     setVideoError(null);
     setVideoPhase("uploading");
 
@@ -2920,7 +3170,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
       return;
     }
     addToLibrary(media.data, "upload", media.data.mime);
-    placeMedia({ ref: media.data, origin: "upload", label: media.data.mime });
+    place({ ref: media.data, origin: "upload", label: media.data.mime });
     setVideoPhase("idle");
     setShowVideoPicker(false);
   }
@@ -2929,7 +3179,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   // was library-only for images, which forced a detour through another
   // station just to use a file that's sitting on disk). Upload → ingest →
   // guard kind==="image" → attach as the part + into the library for reuse.
-  async function onPickImage(file: File) {
+  async function onPickImage(file: File, place: (media: PartMedia) => void = placePickedImage) {
     setImageError(null);
     setImagePhase("uploading");
 
@@ -2979,11 +3229,149 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
       return;
     }
     addToLibrary(media.data, "upload", media.data.mime);
-    placePickedImage({ ref: media.data, origin: "upload", label: media.data.mime });
+    place({ ref: media.data, origin: "upload", label: media.data.mime });
     setImagePhase("idle");
     setShowImagePicker(false);
   }
 
+  // ── k93 §B.5 — the picker BODIES (browse-from-disk + library grid), factored so
+  // the same markup renders inline inside a card, under the toolbar (the `[+ video]`
+  // pretext) and in the station-level append pickers. `onPick` receives the chosen
+  // media as a PartMedia; the caller decides where it lands.
+  function renderImagePickerBody(onPick: (media: PartMedia) => void) {
+    return (
+      <>
+        <div className="vi-gen-video-upload">
+          <AddFileBar
+            accept="image/*"
+            onFile={(f) => onPickImage(f, onPick)}
+            busy={imageBusy}
+            buttonLabel="Choose image from disk"
+          >
+            {imageBusy && <span className="vi-crop-status">Uploading…</span>}
+          </AddFileBar>
+          {imageError && <span className="vi-error">{imageError}</span>}
+        </div>
+        {libraryImages.length === 0 ? (
+          <p className="vi-crop-hint">
+            Nothing in the session library yet — browse above, pick frames in the
+            Frames station, or generate an image; results land here and become
+            pickable.
+          </p>
+        ) : (
+          <LibraryGroups
+            seed={mode}
+            items={libraryImages}
+            defaultOpen={libraryDefaultOpen}
+            renderItem={(it) => (
+              <button
+                type="button"
+                key={it.ref.uri}
+                className="vi-gen-pick-cell"
+                onClick={() => onPick({ ref: it.ref, origin: it.origin, label: it.label })}
+                title={it.ref.uri}
+              >
+                <img
+                  className="vi-gen-pick-thumb"
+                  src={mediaBytesUrl(it.ref.uri)}
+                  alt={it.label ?? "library image"}
+                  loading="lazy"
+                />
+                <span className="vi-gen-pick-meta">
+                  {it.origin}
+                  {it.label ? ` · ${it.label}` : ""}
+                </span>
+              </button>
+            )}
+          />
+        )}
+      </>
+    );
+  }
+  function renderVideoPickerBody(onPick: (media: PartMedia) => void) {
+    return (
+      <>
+        <div className="vi-gen-video-upload">
+          <AddFileBar
+            accept="video/*"
+            onFile={(f) => onPickVideo(f, onPick)}
+            busy={videoBusy}
+            buttonLabel="Choose video from disk"
+          >
+            {videoBusy && <span className="vi-crop-status">Uploading…</span>}
+          </AddFileBar>
+          {videoError && <span className="vi-error">{videoError}</span>}
+        </div>
+        {libraryVideos.length === 0 ? (
+          <p className="vi-crop-hint">
+            No videos in the session library yet — browse above or ingest one in
+            another station.
+          </p>
+        ) : (
+          <LibraryGroups
+            seed={mode}
+            items={libraryVideos}
+            defaultOpen={libraryDefaultOpen}
+            renderItem={(it) => (
+              <button
+                type="button"
+                key={it.ref.uri}
+                className="vi-gen-pick-cell"
+                onClick={() => onPick({ ref: it.ref, origin: it.origin, label: it.label })}
+                title={it.ref.uri}
+              >
+                <span className="vi-gen-pick-videoicon" aria-hidden>
+                  ▶
+                </span>
+                <span className="vi-gen-pick-meta">
+                  <code>{it.ref.mime}</code> · {it.origin}
+                </span>
+              </button>
+            )}
+          />
+        )}
+      </>
+    );
+  }
+  /** The whole library (images + videos) — the inline `+ library` APPEND panel. */
+  function renderLibraryPickerBody(onPick: (media: PartMedia) => void) {
+    return library.length === 0 ? (
+      <p className="vi-crop-hint">Nothing in the session library yet.</p>
+    ) : (
+      <LibraryGroups
+        seed={mode}
+        items={library}
+        defaultOpen={libraryDefaultOpen}
+        renderItem={(it) => (
+          <button
+            type="button"
+            key={it.ref.uri}
+            className="vi-gen-pick-cell"
+            onClick={() => onPick({ ref: it.ref, origin: it.origin, label: it.label })}
+            title={it.ref.uri}
+          >
+            {it.ref.kind === "image" ? (
+              <img
+                className="vi-gen-pick-thumb"
+                src={mediaBytesUrl(it.ref.uri)}
+                alt={it.label ?? "library image"}
+                loading="lazy"
+              />
+            ) : (
+              <span className="vi-gen-pick-videoicon" aria-hidden>
+                ▶
+              </span>
+            )}
+            <span className="vi-gen-pick-meta">
+              {it.ref.kind === "image" ? it.origin : <><code>{it.ref.mime}</code> · {it.origin}</>}
+              {it.label ? ` · ${it.label}` : ""}
+            </span>
+          </button>
+        )}
+      />
+    );
+  }
+
   // ---- run validation (no silent defaults; every gate is visible) ----
   const widthNum = toNumberOrNull(width);
   const heightNum = toNumberOrNull(height);
@@ -3136,6 +3524,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
       if (!p.media || p.text.trim() !== "") {
         out.push({ kind: "text", text: p.text });
       }
+      if (p.frame) out.push({ kind: "image", media: p.frame.ref });
       if (p.media) {
         out.push(
           p.media.ref.kind === "video"
@@ -3148,11 +3537,12 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   }
 
   // The composer's MEDIA parts only (images / videos / bound identity views), with
-  // every text segment dropped. Tester rows supply their own text and inherit these,
+  // every text segment dropped. Tester rows supply their own text and reuse these,
   // so the reference material is identical across a sweep.
   function buildMediaOnlyParts(): GenPromptPart[] {
     const out: GenPromptPart[] = [];
     for (const p of parts) {
+      if (p.frame) out.push({ kind: "image", media: p.frame.ref });
       if (p.media) {
         out.push(
           p.media.ref.kind === "video"
@@ -3175,7 +3565,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
   // setting and has no tick — it always carries, because a row with no prompt is
   // not runnable and would just be a blank card.
   //
-  // The new row inherits the source's tick pattern too, so a sweep keeps sweeping:
+  // The new row copies the source's tick pattern too, so a sweep keeps sweeping:
   // untick `seed` once and every row spun off the chain keeps re-randomizing.
   function seedTestRow(index: number, from: ImageTestRow | undefined): ImageTestRow {
     const ticks = from ? from.carry : carry;
@@ -3196,13 +3586,13 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
           : guidance
         : DEFAULT_KNOBS.guidance,
       seed: ticks.seed ? (from ? from.seed : seed) : DEFAULT_KNOBS.seed,
-      // k89: a row seeded from the BASE composer carries the COMPOSED negative
-      // (user text + the standard set when part #1's tick is on) — the same value
-      // the scene submit sends, so a sweep row reproduces the base generation.
+      // k93: a row seeded from the BASE composer carries part #1's VISIBLE
+      // negative — the same value the scene submit sends, so a sweep row
+      // reproduces the base generation.
       negative: ticks.negative
         ? from
           ? from.negative
-          : composeNegative(negative, sceneStdNegative)
+          : sceneGroupNegative()
         : DEFAULT_NEGATIVE,
       carry: { ...ticks },
     };
@@ -3546,10 +3936,10 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
       steps: stepsNum,
       guidance: guidanceNum,
       seed: seed.trim() === "" ? null : seedNum,
-      // Same composed value as the scene path — the retained image-job wiring must
-      // not drift from what the live submit sends.
+      // Same explicit value as the scene path (part #1's visible field) — the
+      // retained image-job wiring must not drift from what the live submit sends.
       negative: (() => {
-        const eff = composeNegative(negative, sceneStdNegative);
+        const eff = sceneGroupNegative();
         return eff === "" ? null : eff;
       })(),
       project: projectName.trim() || undefined,
@@ -3652,9 +4042,10 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                 to frames server-side.
               </p>
               <p>
-                Each prompt has its OWN Negative tab (blank = inherit the shared
-                negative from a preset or the toolbar); [standard negative] composes
-                the standard exclusion set into that prompt at submit.
+                Each prompt has its OWN Negative tab, sent exactly as written (blank
+                = none; nothing is merged at submit). The std. tick inserts or
+                removes the standard exclusion set in that field; part #1&apos;s
+                Negative is also the group assist&apos;s shared negative.
               </p>
               <p>
                 The Tester at the bottom compares prompts, settings and models side
@@ -4467,53 +4858,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                     timeline.
                   </p>
                 )}
-                {/* Browse-from-disk — attach was library-only for images. */}
-                <div className="vi-gen-video-upload">
-                  <AddFileBar
-                    accept="image/*"
-                    onFile={onPickImage}
-                    busy={imageBusy}
-                    buttonLabel="Choose image from disk"
-                  >
-                    {imageBusy && (
-                      <span className="vi-crop-status">Uploading…</span>
-                    )}
-                  </AddFileBar>
-                  {imageError && <span className="vi-error">{imageError}</span>}
-                </div>
-                {libraryImages.length === 0 ? (
-                  <p className="vi-crop-hint">
-                    Nothing in the session library yet — browse above, pick
-                    frames in the Frames station, or generate an image; results
-                    land here and become pickable.
-                  </p>
-                ) : (
-                  <LibraryGroups
-                    seed={mode}
-                    items={libraryImages}
-                    defaultOpen={libraryDefaultOpen}
-                    renderItem={(it) => (
-                      <button
-                        type="button"
-                        key={it.ref.uri}
-                        className="vi-gen-pick-cell"
-                        onClick={() => addImage(it)}
-                        title={it.ref.uri}
-                      >
-                        <img
-                          className="vi-gen-pick-thumb"
-                          src={mediaBytesUrl(it.ref.uri)}
-                          alt={it.label ?? "library image"}
-                          loading="lazy"
-                        />
-                        <span className="vi-gen-pick-meta">
-                          {it.origin}
-                          {it.label ? ` · ${it.label}` : ""}
-                        </span>
-                      </button>
-                    )}
-                  />
-                )}
+                {renderImagePickerBody(addImageMedia)}
               </div>
             )}
 
@@ -4531,42 +4876,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                   sampling); for precise control, extract + pick frames in the
                   Frames station and add them as images.
                 </p>
-                <div className="vi-gen-video-upload">
-                  <AddFileBar
-                    accept="video/*"
-                    onFile={onPickVideo}
-                    busy={videoBusy}
-                    buttonLabel="Choose video from disk"
-                  >
-                    {videoBusy && (
-                      <span className="vi-crop-status">Uploading…</span>
-                    )}
-                  </AddFileBar>
-                  {videoError && <span className="vi-error">{videoError}</span>}
-                </div>
-                {libraryVideos.length > 0 && (
-                  <LibraryGroups
-                    seed={mode}
-                    items={libraryVideos}
-                    defaultOpen={libraryDefaultOpen}
-                    renderItem={(it) => (
-                      <button
-                        type="button"
-                        key={it.ref.uri}
-                        className="vi-gen-pick-cell"
-                        onClick={() => addVideoFromLibrary(it)}
-                        title={it.ref.uri}
-                      >
-                        <span className="vi-gen-pick-videoicon" aria-hidden>
-                          ▶
-                        </span>
-                        <span className="vi-gen-pick-meta">
-                          <code>{it.ref.mime}</code> · {it.origin}
-                        </span>
-                      </button>
-                    )}
-                  />
-                )}
+                {renderVideoPickerBody(addVideoMedia)}
               </div>
             )}
           </>
@@ -4804,9 +5114,9 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                     label: "Goals",
                     value: goals.length,
                     min: 1,
-                    max: MAX_MOVIE_GOALS,
                     onChange: setGoalCount,
-                    title: `How many goals the timeline has (1–${MAX_MOVIE_GOALS}). Lowering it removes rows from the END of the timeline.`,
+                    title:
+                      "How many goals the timeline has. Lowering it parks rows from the END of the timeline; raising it brings them back before adding blanks.",
                   }}
                   noun="goal"
                   selectedCount={movieSelectedCount}
@@ -5138,9 +5448,12 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                 {/* The station-wide "whole assembled prompt" Enhance/Generate cluster
                     was removed (operator): per-part Enhance/Generate on each card and
                     the toolbar's group "Generate prompts (N selected)" below cover it. */}
-                {/* k89 — the SHARED prompt-list toolbar (same structure Movie and
-                    Cinema render): part count, select-all, the one-call spread, the
-                    negative writer and the standard-negative tick. */}
+                {/* k89/k93 — the SHARED prompt-list toolbar in its GROUP layout:
+                      prompt assist model  [select]
+                      [start] - [end]  [ ] select all   negatives: [on/off]  [ ] std.
+                      (✨ generate (N selected)) (✨ enhance (M selected)) [+ video]
+                    The selection SET (sceneSelectedIds) stays the source of truth;
+                    range / select-all / per-card ticks all write into it. */}
                 <PromptListToolbar
                   count={{
                     id: "vi-gen-part-count",
@@ -5156,52 +5469,117 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                   itemCount={sceneTextParts.length}
                   allSelected={sceneAllSelected}
                   onToggleSelectAll={toggleSceneSelectAll}
+                  modelRow={
+                    /* PROMPT-ASSIST MODEL — ONE shared selector for which text
+                       generator the group actions (and every card's default) use. */
+                    assist.assistModels.length > 0 ? (
+                      <div className="vi-prompt-assist vi-gen-assist-model">
+                        <span className="vi-prompt-assist-lead" aria-hidden="true">
+                          prompt assist model
+                        </span>
+                        <select
+                          className="vi-select vi-select-sm"
+                          value={assist.assistModel ?? ""}
+                          disabled={assist.assistBusy != null}
+                          onChange={(e) => assist.setAssistModel(e.target.value || null)}
+                          aria-label="Text generator used to enhance or generate prompts"
+                          title="Which text generator writes prompts for the group actions and every prompt's Enhance / Generate (a card can pick its own)."
+                        >
+                          <option value="">fleet default</option>
+                          {assist.assistModels.map((m) => (
+                            <option key={m.model} value={m.model}>
+                              {m.model}
+                              {m.serving ? "" : " · cold"}
+                            </option>
+                          ))}
+                        </select>
+                      </div>
+                    ) : null
+                  }
+                  range={{
+                    start: sceneRangeStart,
+                    end: sceneRangeEnd,
+                    onChange: selectSceneRange,
+                  }}
+                  negativesOn={sceneGroupNegatives}
+                  onNegativesOnChange={setSceneGroupNegatives}
+                  negativesOnTitle="On: generate / enhance also write each selected part's Negative field (visible; sent as-is). Off: prompts only."
+                  stdChecked={sceneStdAllOn}
+                  onStdChange={onSceneStdChange}
+                  stdTitle="Tick: insert the standard exclusion set into every selected part's Negative field. Untick: remove exactly those terms. What you see in the field is what is sent."
                   generateLabel={
                     assist.assistBusy === "spread"
-                      ? "✨ Writing the spread…"
-                      : `✨ Generate prompts (${sceneSelectedCount} selected)`
+                      ? "✨ writing the spread…"
+                      : `✨ generate (${sceneSelectedCount} selected)`
                   }
-                  generateTitle="ONE call writes every ticked text part against one shared world; unticked parts and media captions ride along as locked context."
-                  generateDisabledTitle="Tick the text parts you want written."
+                  generateTitle="ONE call writes every selected text part against one shared world; unselected parts and media captions ride along as locked context. Part #1's Negative field is sent as the shared negative."
+                  generateDisabledTitle="Select the text parts you want written (range, select all, or the per-card ticks)."
                   onGenerate={() => void onSceneSpreadSelected()}
-                  negativesLabel={
-                    assist.assistBusy === "negative"
-                      ? "✨ Writing the negative…"
-                      : `✨ Generate negative (${sceneSelectedCount} selected)`
+                  enhanceLabel={
+                    assist.assistBusy === "detail"
+                      ? "✨ enhancing…"
+                      : `✨ enhance (${sceneEnhanceCount} selected)`
                   }
-                  negativesTitle="Write an artifact/quality exclusion list for the scene's ONE negative, from the ticked parts' text."
-                  onNegatives={() => void onSceneNegativesSelected()}
+                  enhanceTitle={
+                    sceneEnhanceCount === 0
+                      ? "Enhance needs selected parts with a non-blank prompt."
+                      : "Enrich each selected non-blank prompt with more descriptive detail (one part at a time)."
+                  }
+                  canEnhance={sceneEnhanceCount > 0}
+                  onEnhance={() => void onSceneEnhanceSelected()}
+                  // Legacy single-line props (unused in the group layout, kept typed).
+                  negativesLabel=""
+                  onNegatives={() => undefined}
+                  onStandardNegatives={() => undefined}
                   assistBusy={assist.assistBusy != null}
-                  onStandardNegatives={onSceneStandardNegatives}
-                  standardNegativesTitle="Writes a shared negative that every prompt with a blank Negative tab inherits; each prompt can override it on its own Negative tab."
-                />
-                {/* PROMPT-ASSIST MODEL — ONE shared selector for which text
-                    generator every prompt's Enhance/Generate uses (the per-card
-                    buttons all drive this same assist model). Defaults to
-                    flux-klein-uncensored via the effect above. */}
-                {assist.assistModels.length > 0 && (
-                  <div className="vi-prompt-assist vi-gen-assist-model">
-                    <span className="vi-prompt-assist-lead" aria-hidden="true">
-                      prompt assist model
-                    </span>
-                    <select
-                      className="vi-select vi-select-sm"
-                      value={assist.assistModel ?? ""}
-                      disabled={assist.assistBusy != null}
-                      onChange={(e) => assist.setAssistModel(e.target.value || null)}
-                      aria-label="Text generator used to enhance or generate prompts"
-                      title="Which text generator writes prompts for every prompt's Enhance / Generate."
+                  actionsExtra={
+                    <button
+                      type="button"
+                      className={`vi-btn vi-btn-sm vi-btn-ghost${scenePretext ? " vi-btn-on" : ""}`}
+                      onClick={() => setScenePretextOpen((v) => !v)}
+                      aria-expanded={scenePretextOpen}
+                      title="Attach ONE video as pretext: it is analyzed server-side and its description is fed to generate / enhance as context (not a prompt part)."
                     >
-                      <option value="">fleet default</option>
-                      {assist.assistModels.map((m) => (
-                        <option key={m.model} value={m.model}>
-                          {m.model}
-                          {m.serving ? "" : " · cold"}
-                        </option>
-                      ))}
-                    </select>
-                  </div>
-                )}
+                      {scenePretext ? "▶ video pretext ✓" : "+ video"}
+                    </button>
+                  }
+                  below={
+                    (scenePretextOpen || scenePretext) && (
+                      <div className="vi-gen-inline-attach vi-gen-pretext">
+                        {scenePretext ? (
+                          <div className="vi-gen-part-media">
+                            <span className="vi-gen-part-videoicon" aria-hidden>
+                              ▶
+                            </span>
+                            <span className="vi-gen-part-meta">
+                              <code>{scenePretext.ref.mime}</code>
+                              {scenePretext.origin ? ` · ${scenePretext.origin}` : ""}
+                              {scenePretext.label ? ` · ${scenePretext.label}` : ""}
+                              {" · described server-side as pretext for generate / enhance"}
+                            </span>
+                            <button
+                              type="button"
+                              className="vi-btn vi-btn-sm vi-btn-ghost"
+                              onClick={() => {
+                                setScenePretext(null);
+                                setScenePretextOpen(false);
+                              }}
+                              aria-label="Remove the pretext video"
+                              title="Remove the pretext video"
+                            >
+                              ✕
+                            </button>
+                          </div>
+                        ) : (
+                          renderVideoPickerBody((it) => {
+                            setScenePretext(it);
+                            setScenePretextOpen(false);
+                          })
+                        )}
+                      </div>
+                    )
+                  }
+                />
                 {/* GROUP SETTINGS — the settings counterpart to the group prompt
                     assist: whichever prompt components are selected get these
                     settings (applied as their own per-part overrides). */}
@@ -5319,14 +5697,16 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                           : "Remove"
                       }
                     >
-                      {/* [Prompt][Negative] tabs over ONE GoalComposer pane. Per
-                          the per-part refactor, EVERY part edits its OWN negative
-                          (p.negative); a blank one inherits the shared station
-                          negative (preset / toolbar) at submit, and [standard
-                          negative] composes the standard set into that part per its
-                          own tick (default = the shared sceneStdNegative). */}
+                      {/* [Prompt][Negative] tabs over ONE GoalComposer pane (labels
+                          visually hidden — the tabs say it). k93: EVERY part sends
+                          exactly what its own Negative field holds; blank is blank.
+                          Part #1's field is also the group assist's shared negative
+                          (its tab tooltip says so). The std. tick lives in the
+                          assist row below and reads its state from the field. */}
                       <PromptFieldTabs
                         idPrefix={`vi-gen-part-${p.key}`}
+                        hideLabels
+                        hideStdTick
                         promptLabel={
                           p.media
                             ? `caption (optional — sent as text just before the ${kind})`
@@ -5340,120 +5720,275 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                             : "Describe what to generate…"
                         }
                         rows={2}
+                        negativeLabel="negative prompt"
                         negative={p.negative ?? ""}
                         onNegativeChange={(v) => patchPart(p.key, { negative: v })}
-                        negativePlaceholder="what to avoid — blank = inherit shared"
-                        negativeHint="Blank = inherit the shared negative (presets / toolbar)."
-                        stdNegative={p.stdNegative ?? sceneStdNegative}
-                        onStdNegativeChange={(v) => patchPart(p.key, { stdNegative: v })}
+                        negativePlaceholder="what to avoid (sent exactly as written; blank = none)"
+                        negativeTabTitle={
+                          !p.media && sceneTextParts[0]?.key === p.key
+                            ? "This part's negative. Part #1's Negative field is ALSO sent as the shared negative of the group generate / enhance — explicitly, never merged."
+                            : "This part's negative — sent exactly as written with this part's request."
+                        }
+                        stdNegative={hasStandardNegative(p.negative ?? "")}
+                        onStdNegativeChange={(v) => onPartStdChange(p, v)}
                         negativeDisabledNote={undefined}
                         negativeExtras={undefined}
                       />
 
-                      {/* Per-part Enhance/Generate (operator: Scene → per-component,
-                          reversing the k86/k89 station-wide cluster). Mirrors Movie's
-                          per-goal wiring: assist targets THIS part's text and writes
-                          back to it. Text parts only — media parts carry captions and
-                          ride the group actions as locked context. One in-flight assist
-                          at a time across all parts. */}
+                      {/* k93 §B — the per-card assist row:
+                            prompt assist model [select]
+                            negatives: [on/off]  [ ] std.   (✨ generate) (✨ enhance)
+                          Text parts only — media parts carry captions and ride the
+                          group actions as locked context. One in-flight assist at a
+                          time across all parts. */}
                       {!p.media && (
-                        <PromptAssistButtons
-                          busy={assist.assistBusy}
-                          error={assist.assistError}
-                          onDismissError={assist.dismissError}
-                          onEnhance={() => void runPartAssist(p, "detail")}
-                          onGenerate={() => void runPartAssist(p, "generate")}
-                          canEnhance={p.text.trim() !== ""}
-                          models={assist.assistModels}
-                          model={p.assistModel ?? assist.assistModel}
-                          onModelChange={(m) =>
-                            patchPart(p.key, { assistModel: m })
-                          }
-                        />
+                        <div className="vi-gen-part-assist-row">
+                          <label
+                            className="vi-comfy-hint vi-prompt-toolbar-neg"
+                            title="On: this card's generate / enhance also write its Negative field. Off: the prompt only."
+                          >
+                            negatives:
+                            <button
+                              type="button"
+                              className={`vi-btn vi-btn-sm vi-toggle${(p.assistNegatives ?? true) ? " vi-toggle-on" : ""}`}
+                              role="switch"
+                              aria-checked={p.assistNegatives ?? true}
+                              onClick={() =>
+                                patchPart(p.key, { assistNegatives: !(p.assistNegatives ?? true) })
+                              }
+                            >
+                              {(p.assistNegatives ?? true) ? "on" : "off"}
+                            </button>
+                          </label>
+                          <label
+                            className="vi-comfy-hint vi-prompt-toolbar-std"
+                            title="Tick: insert the standard exclusion set into this part's Negative field. Untick: remove exactly those terms. What you see is what is sent."
+                          >
+                            <input
+                              type="checkbox"
+                              checked={hasStandardNegative(p.negative ?? "")}
+                              onChange={(e) => onPartStdChange(p, e.target.checked)}
+                              aria-label={`Insert the standard negative into part ${i + 1}`}
+                            />
+                            std.
+                          </label>
+                          <PromptAssistButtons
+                            busy={assist.assistBusy}
+                            error={assist.assistError}
+                            onDismissError={assist.dismissError}
+                            onEnhance={() => void runPartAssist(p, "detail")}
+                            onGenerate={() => void runPartAssist(p, "generate")}
+                            canEnhance={p.text.trim() !== ""}
+                            models={assist.assistModels}
+                            model={p.assistModel ?? assist.assistModel}
+                            onModelChange={(m) =>
+                              patchPart(p.key, { assistModel: m })
+                            }
+                          />
+                        </div>
                       )}
 
                       {p.media ? (
-                        <div className="vi-gen-part-media">
-                          {kind === "image" ? (
-                            <img
-                              className="vi-gen-part-thumb"
-                              src={mediaBytesUrl(p.media.ref.uri)}
-                              alt="Prompt image part"
-                              loading="lazy"
-                            />
-                          ) : (
-                            <span className="vi-gen-part-videoicon" aria-hidden>
-                              ▶
+                        <div className="vi-gen-part-media-block">
+                          <div className="vi-gen-part-media">
+                            {kind === "image" ? (
+                              <img
+                                className="vi-gen-part-thumb"
+                                src={mediaBytesUrl(p.media.ref.uri)}
+                                alt="Prompt image part"
+                                loading="lazy"
+                              />
+                            ) : (
+                              <span className="vi-gen-part-videoicon" aria-hidden>
+                                ▶
+                              </span>
+                            )}
+                            <span className="vi-gen-part-meta">
+                              <code>{p.media.ref.mime}</code>
+                              {p.media.origin ? ` · ${p.media.origin}` : ""}
+                              {p.media.label ? ` · ${p.media.label}` : ""}
+                              {kind === "video"
+                                ? " · resolved to frames server-side"
+                                : ""}
                             </span>
+                            <button
+                              type="button"
+                              className="vi-btn vi-btn-sm vi-btn-ghost"
+                              onClick={() => detachMedia(p.key)}
+                              aria-label="Detach media"
+                              title="Detach media (keeps the text)"
+                            >
+                              ✕ media
+                            </button>
+                          </div>
+                          {/* k93 §B.6 — pull ONE frame out of the attached video
+                              (frame-extract job → the frame becomes this part's
+                              image / start frame AND lands in the library). */}
+                          {kind === "video" && (
+                            <div className="vi-gen-part-pullframe">
+                              <label className="vi-comfy-hint" htmlFor={`vi-gen-pull-${p.key}`}>
+                                pull frame @
+                              </label>
+                              <input
+                                id={`vi-gen-pull-${p.key}`}
+                                type="number"
+                                className="vi-knob-input vi-gen-pull-input"
+                                min={0}
+                                step={0.1}
+                                max={p.media.ref.duration_s ?? undefined}
+                                value={pullFrameAt[p.key] ?? "0"}
+                                onChange={(e) =>
+                                  setPullFrameAt((prev) => ({ ...prev, [p.key]: e.target.value }))
+                                }
+                                aria-label="Time in seconds of the frame to pull"
+                              />
+                              <span className="vi-comfy-hint">
+                                s{p.media.ref.duration_s != null ? ` / ${p.media.ref.duration_s.toFixed(1)}` : ""}
+                              </span>
+                              <button
+                                type="button"
+                                className="vi-btn vi-btn-sm"
+                                disabled={pullFrameJobs[p.key] != null}
+                                onClick={() => pullFrame(p)}
+                                title="Extract the frame at this time (frame-extract job). The still becomes this part's start image and is added to the library."
+                              >
+                                {pullFrameJobs[p.key] != null ? "pulling…" : "pull frame"}
+                              </button>
+                              {pullFrameError[p.key] && (
+                                <span className="vi-error">{pullFrameError[p.key]}</span>
+                              )}
+                            </div>
+                          )}
+                          {p.frame && (
+                            <div className="vi-gen-part-media">
+                              <img
+                                className="vi-gen-part-thumb"
+                                src={mediaBytesUrl(p.frame.ref.uri)}
+                                alt="Frame pulled from the attached video"
+                                loading="lazy"
+                              />
+                              <span className="vi-gen-part-meta">
+                                <code>{p.frame.ref.mime}</code>
+                                {p.frame.label ? ` · ${p.frame.label}` : ""}
+                                {" · sent as this part's start image (before the video)"}
+                              </span>
+                              <button
+                                type="button"
+                                className="vi-btn vi-btn-sm vi-btn-ghost"
+                                onClick={() => detachFrame(p.key)}
+                                aria-label="Drop the pulled frame"
+                                title="Drop the pulled frame (keeps the video)"
+                              >
+                                ✕ frame
+                              </button>
+                            </div>
                           )}
-                          <span className="vi-gen-part-meta">
-                            <code>{p.media.ref.mime}</code>
-                            {p.media.origin ? ` · ${p.media.origin}` : ""}
-                            {p.media.label ? ` · ${p.media.label}` : ""}
-                            {kind === "video"
-                              ? " · resolved to frames server-side"
-                              : ""}
-                          </span>
-                          <button
-                            type="button"
-                            className="vi-btn vi-btn-sm vi-btn-ghost"
-                            onClick={() => detachMedia(p.key)}
-                            aria-label="Detach media"
-                            title="Detach media (keeps the text)"
-                          >
-                            ✕ media
-                          </button>
                         </div>
                       ) : (
-                        <div className="vi-gen-part-attach">
-                          <button
-                            type="button"
-                            className="vi-btn vi-btn-sm vi-btn-ghost"
-                            onClick={() => openAttachPicker(p.key, "image")}
-                            title="Pick an image that pairs with this part's text"
-                          >
-                            + attach image
-                          </button>
-                          <button
-                            type="button"
-                            className="vi-btn vi-btn-sm vi-btn-ghost"
-                            onClick={() => openAttachPicker(p.key, "video")}
-                            title="Pick a video that pairs with this part's text"
-                          >
-                            + attach video
-                          </button>
-                          {/* k89 — the add bar's library-APPEND path, reachable from
-                              the card (adds a NEW image part rather than pairing). */}
-                          <button
-                            type="button"
-                            className="vi-btn vi-btn-sm vi-btn-ghost"
-                            onClick={() => {
-                              setAttachTarget(null); // append mode, not attach
-                              setShowImagePicker((v) => !v);
-                              setShowVideoPicker(false);
-                            }}
-                            title="Append an image part from the library (a new part, not paired with this one)"
-                          >
-                            + from library
-                          </button>
-                        </div>
+                        <>
+                          {/* k93 §B.5 — the attach row; each button EXPANDS its
+                              picker inline right under this row. */}
+                          <div className="vi-gen-part-attach">
+                            <button
+                              type="button"
+                              className={`vi-btn vi-btn-sm vi-btn-ghost${partAttachOpen?.key === p.key && partAttachOpen.kind === "image" ? " vi-btn-on" : ""}`}
+                              onClick={() => openAttachPicker(p.key, "image")}
+                              aria-expanded={partAttachOpen?.key === p.key && partAttachOpen.kind === "image"}
+                              title="Pick an image that pairs with this part's text"
+                            >
+                              + image
+                            </button>
+                            <button
+                              type="button"
+                              className={`vi-btn vi-btn-sm vi-btn-ghost${partAttachOpen?.key === p.key && partAttachOpen.kind === "video" ? " vi-btn-on" : ""}`}
+                              onClick={() => openAttachPicker(p.key, "video")}
+                              aria-expanded={partAttachOpen?.key === p.key && partAttachOpen.kind === "video"}
+                              title="Pick a video that pairs with this part's text (a frame can then be pulled from it)"
+                            >
+                              + video
+                            </button>
+                            <button
+                              type="button"
+                              className={`vi-btn vi-btn-sm vi-btn-ghost${partAttachOpen?.key === p.key && partAttachOpen.kind === "library" ? " vi-btn-on" : ""}`}
+                              onClick={() => openAttachPicker(p.key, "library")}
+                              aria-expanded={partAttachOpen?.key === p.key && partAttachOpen.kind === "library"}
+                              title="Append a media part from the library (a new part, not paired with this one)"
+                            >
+                              + library
+                            </button>
+                          </div>
+                          {partAttachOpen?.key === p.key && (
+                            <div className="vi-gen-inline-attach">
+                              {partAttachOpen.kind === "image" && (
+                                <>
+                                  <p className="vi-crop-hint">
+                                    The picked image pairs with this part&apos;s text.
+                                  </p>
+                                  {renderImagePickerBody(placeMedia)}
+                                </>
+                              )}
+                              {partAttachOpen.kind === "video" && (
+                                <>
+                                  <p className="vi-crop-hint">
+                                    The picked video pairs with this part&apos;s text; it is
+                                    resolved into frames server-side, or pull one frame
+                                    from it afterwards.
+                                  </p>
+                                  {renderVideoPickerBody(placeMedia)}
+                                </>
+                              )}
+                              {partAttachOpen.kind === "library" && (
+                                <>
+                                  <p className="vi-crop-hint">
+                                    Appends a NEW media part after the last one.
+                                  </p>
+                                  {renderLibraryPickerBody((m) => {
+                                    setAttachTarget(null);
+                                    placeMedia(m);
+                                  })}
+                                </>
+                              )}
+                            </div>
+                          )}
+                        </>
                       )}
 
                       {/* IDENTITY — the generation-wide character, selectable from
-                          ANY part (alongside that part's "from library"/attach
-                          controls) because ONE identity is shared by the whole
-                          generation. Rendered on every part and driven by the SAME
-                          bound state, so all parts always agree; the profile list
-                          comes from the station's single useIdentityProfiles(). */}
-                      <GenIdentityBar
-                        profiles={identityProfiles}
-                        loading={identityLoading}
-                        error={identityError}
-                        bound={boundIdentity}
-                        onBind={bindIdentity}
-                        onClear={clearIdentity}
-                        disabled={running}
-                      />
+                          ANY part because ONE identity is shared by the whole
+                          generation. k93 §B.7: rendered as a single `+ identity`
+                          button that expands inline (same row idiom); shows bound
+                          when one is set. */}
+                      <div className="vi-gen-part-attach">
+                        <button
+                          type="button"
+                          className={`vi-btn vi-btn-sm vi-btn-ghost${identityOpen.has(p.key) || boundIdentity ? " vi-btn-on" : ""}`}
+                          aria-expanded={identityOpen.has(p.key)}
+                          onClick={() =>
+                            setIdentityOpen((prev) => {
+                              const next = new Set(prev);
+                              if (next.has(p.key)) next.delete(p.key);
+                              else next.add(p.key);
+                              return next;
+                            })
+                          }
+                          title="Bind an identity profile (one per generation — shared by every part)"
+                        >
+                          {boundIdentity ? `+ identity ✓ ${boundIdentity.name}` : "+ identity"}
+                        </button>
+                      </div>
+                      {identityOpen.has(p.key) && (
+                        <div className="vi-gen-inline-attach">
+                          <GenIdentityBar
+                            profiles={identityProfiles}
+                            loading={identityLoading}
+                            error={identityError}
+                            bound={boundIdentity}
+                            onBind={bindIdentity}
+                            onClear={clearIdentity}
+                            disabled={running}
+                          />
+                        </div>
+                      )}
 
                       {renderPartSettings(p)}
                       {renderPartResult(p)}
@@ -5476,7 +6011,7 @@ export function GenerateStation({ spec }: { spec: StationSpec }) {
                 contract, and scene's own knobs (frames/motion/fps/assemble/strength/
                 chain) stay in the rail because they describe the SCENE, not the frame.
 
-                The ticks decide what a component seeded from this one inherits; in
+                The ticks decide what a component seeded from this one receives; in
                 scene mode generation itself just reads the values as it always has.
 
                 k89: the strip stays STATION-WIDE (it configures the single