From f5c709924b69fade6b225457b5c1141cfe42fd8b Mon Sep 17 00:00:00 2001
From: Towsty <ianjmcarr@gmail.com>
Date: Wed, 26 Aug 2026 00:01:25 -0500
Subject: [PATCH] Ship extension queues, library extend, and smoother seam
 stitching.

Users can pre-queue extensions, extend from the library with p2 titles, blend seams with xfade, and a unreadable catalog is no longer replaced with an empty one.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 pages/index.vue             | 193 +++++++++++++++++++++++++++---
 server/api/extend.post.ts   |   2 +-
 server/api/generate.post.ts | 228 ++++++++++++++++++++++++++++++------
 server/utils/ffmpeg.ts      | 147 ++++++++++++++++++++++-
 server/utils/jobs.ts        |  21 +++-
 server/utils/library.ts     |  28 ++++-
 server/utils/watch.ts       | 113 +++++++++++++++---
 7 files changed, 653 insertions(+), 79 deletions(-)

diff --git a/pages/index.vue b/pages/index.vue
index 8bdc32a..f40cfad 100644
--- a/pages/index.vue
+++ b/pages/index.vue
@@ -67,6 +67,61 @@
           />
         </div>
 
+        <div class="space-y-3">
+          <div
+            v-for="(item, index) in extensionQueue"
+            :key="item.id"
+            class="rounded-2xl border border-white/10 bg-zinc-950/50 p-4"
+          >
+            <div class="mb-3 flex items-center justify-between gap-2">
+              <p class="text-sm font-medium text-zinc-200">Extension #{{ index + 1 }}</p>
+              <button
+                type="button"
+                class="text-xs text-red-300 hover:text-red-200"
+                :disabled="busy"
+                @click="removeQueuedExtension(item.id)"
+              >
+                Remove
+              </button>
+            </div>
+            <textarea
+              v-model="item.prompt"
+              rows="3"
+              class="w-full rounded-xl border border-white/10 bg-zinc-950 px-3 py-2 text-sm outline-none ring-amber-300/40 placeholder:text-zinc-600 focus:ring-2"
+              placeholder="Motion prompt for this extension…"
+            />
+            <div class="mt-3">
+              <p class="mb-2 text-xs uppercase tracking-wider text-zinc-500">Duration</p>
+              <div class="grid grid-cols-2 gap-2">
+                <button
+                  type="button"
+                  class="rounded-xl border px-3 py-2 text-sm"
+                  :class="item.duration === 3 ? 'border-amber-300 bg-amber-400/10' : 'border-white/10'"
+                  @click="item.duration = 3"
+                >
+                  3s
+                </button>
+                <button
+                  type="button"
+                  class="rounded-xl border px-3 py-2 text-sm"
+                  :class="item.duration === 5 ? 'border-amber-300 bg-amber-400/10' : 'border-white/10'"
+                  @click="item.duration = 5"
+                >
+                  5s
+                </button>
+              </div>
+            </div>
+          </div>
+          <button
+            type="button"
+            class="w-full rounded-2xl border border-dashed border-white/15 px-4 py-2.5 text-sm text-zinc-300 transition hover:border-amber-300/40 hover:text-amber-100 disabled:cursor-not-allowed disabled:opacity-50"
+            :disabled="busy || extensionQueue.length >= MAX_EXTENSIONS"
+            @click="queueExtension"
+          >
+            + Queue Extension
+          </button>
+        </div>
+
         <div>
           <p class="mb-2 text-sm font-medium text-zinc-300">Save to library</p>
           <div class="space-y-3">
@@ -249,10 +304,10 @@
           <button
             type="button"
             class="flex-1 rounded-2xl bg-amber-400 px-5 py-3 font-semibold text-zinc-950 transition hover:bg-amber-300 disabled:cursor-not-allowed disabled:opacity-50"
-            :disabled="busy || !file || !prompt.trim() || !folderId"
+            :disabled="busy || !file || !prompt.trim() || !folderId || !queueReady"
             @click="generate"
           >
-            {{ busy ? 'Generating…' : 'Generate Video' }}
+            {{ generateLabel }}
           </button>
           <button
             v-if="busy"
@@ -275,7 +330,7 @@
             >
               <button type="button" class="min-w-0 flex-1 text-left" @click="loadDraft(draft)">
                 <p class="truncate text-sm font-medium text-zinc-100">{{ draft.name || draft.prompt }}</p>
-                <p class="mt-0.5 text-xs text-zinc-500">{{ draft.duration }}s · {{ draft.turbo ? 'turbo' : 'quality' }} · {{ draft.sound === false ? 'silent' : 'sound' }} · seed {{ draft.seed }}</p>
+                <p class="mt-0.5 text-xs text-zinc-500">{{ draft.duration }}s · {{ draft.turbo ? 'turbo' : 'quality' }} · {{ draft.sound === false ? 'silent' : 'sound' }} · seed {{ draft.seed }}{{ draft.extensions?.length ? ` · +${draft.extensions.length} ext` : '' }}</p>
               </button>
               <button type="button" class="shrink-0 text-xs text-red-300 hover:text-red-200" @click="dismissDraft(draft)">Dismiss</button>
             </li>
@@ -287,13 +342,20 @@
         <div ref="outputPanel" class="glass rounded-3xl p-5 sm:p-6">
           <div class="flex items-center justify-between gap-3">
             <h2 class="font-display text-2xl font-bold">Output</h2>
-            <p class="text-xs text-zinc-500">{{ elapsedLabel }} · step {{ step }}/{{ maxStep || (turbo ? 8 : 20) }}</p>
+            <p class="text-xs text-zinc-500">
+              {{ elapsedLabel }}
+              <template v-if="chainTotal > 1"> · chain {{ chainStep }}/{{ chainTotal }}</template>
+              · step {{ step }}/{{ maxStep || (turbo ? 8 : 20) }}
+            </p>
           </div>
           <div class="mt-4">
             <div class="mb-2 flex items-center justify-between text-sm">
               <span :class="statusBusy ? 'text-amber-200' : 'text-zinc-300'">{{ statusMessage }}</span>
               <span class="text-amber-200">{{ progress }}%</span>
             </div>
+            <p v-if="chainTotal > 1" class="mb-2 text-xs text-amber-200/80">
+              Step {{ chainStep }}/{{ chainTotal }}{{ chainLabel ? `: ${chainLabel}` : '' }}
+            </p>
             <div class="h-2 overflow-hidden rounded-full bg-zinc-800">
               <div class="h-full rounded-full bg-amber-400 progress-glow transition-all duration-300" :style="{ width: progress + '%' }" />
             </div>
@@ -338,8 +400,9 @@
             Generated MP4 appears here
           </div>
           </div>
-          <div v-if="videoUrl && !awaitingReveal && !lockedSave" class="mt-4 flex flex-wrap gap-3">
+          <div v-if="videoUrl && !lockedSave" class="mt-4 flex flex-wrap gap-3">
             <a
+              v-if="!awaitingReveal"
               :href="videoUrl"
               :download="`${outputDownloadName}.mp4`"
               class="inline-flex rounded-2xl border border-white/15 px-4 py-2 text-sm hover:border-amber-300/50"
@@ -350,17 +413,16 @@
               v-if="canExtend"
               type="button"
               class="inline-flex rounded-2xl border border-amber-300/40 px-4 py-2 text-sm text-amber-100 hover:border-amber-300/70"
-              :disabled="busy"
-              @click="openExtend"
+              @click="openExtend()"
             >
               Extend Video
             </button>
           </div>
-          <div v-if="extendOpen && canExtend" class="mt-4 space-y-4 rounded-2xl border border-white/10 bg-zinc-950/50 p-4">
+          <div v-if="extendOpen" class="mt-4 space-y-4 rounded-2xl border border-white/10 bg-zinc-950/50 p-4">
             <div class="flex items-start justify-between gap-3">
               <div>
                 <h3 class="text-sm font-semibold text-amber-100">Extend this clip</h3>
-                <p class="mt-1 text-xs text-zinc-500">Continue from the last frame with a new motion prompt, then stitch the segments together.</p>
+                <p class="mt-1 text-xs text-zinc-500">Continue from the last frame with a new motion prompt, then stitch the segments together.{{ extendSaveName ? ` Saves as “${extendSaveName}”.` : '' }}</p>
               </div>
               <button type="button" class="text-xs text-zinc-400 hover:text-white" @click="closeExtend">Close</button>
             </div>
@@ -403,7 +465,7 @@
             <button
               type="button"
               class="w-full rounded-2xl bg-amber-400 px-4 py-2.5 text-sm font-semibold text-zinc-950 transition hover:bg-amber-300 disabled:cursor-not-allowed disabled:opacity-50"
-              :disabled="busy || !extendPrompt.trim() || lastFrameLoading"
+              :disabled="!extendPrompt.trim() || lastFrameLoading"
               @click="generateExtension"
             >
               Generate Extension
@@ -495,6 +557,7 @@
                   <p class="text-xs text-zinc-500">{{ item.width && item.height ? `${item.width}×${item.height}` : 'size unknown' }} · {{ item.steps || '—' }} steps · seed {{ item.seed || '—' }}</p>
                   <div class="mt-2 flex flex-wrap items-center gap-3">
                     <button type="button" class="text-xs text-amber-300" @click="openClip(item)">Open</button>
+                    <button type="button" class="text-xs text-amber-300" @click="openExtend(item)">Extend</button>
                     <button type="button" class="text-xs text-amber-300" @click="startRename(item)">Rename</button>
                     <button type="button" class="text-xs text-amber-300" @click="rerun(item)">Rerun</button>
                     <select
@@ -621,6 +684,13 @@ interface RetryDraft {
   fps?: number
   samplerName?: string
   scheduler?: string
+  extensions?: { prompt: string; duration: number }[]
+}
+
+interface QueuedExtension {
+  id: string
+  prompt: string
+  duration: 3 | 5
 }
 
 const PRESETS: Record<Exclude<AspectId, 'auto'>, { width: number; height: number }> = {
@@ -642,6 +712,8 @@ const file = ref<File | null>(null)
 const preview = ref('')
 const dragging = ref(false)
 const prompt = ref('')
+const MAX_EXTENSIONS = 8
+const extensionQueue = ref<QueuedExtension[]>([])
 const clipName = ref('')
 const outputDownloadName = ref('aigen')
 const aspect = ref<AspectId>('auto')
@@ -680,6 +752,9 @@ const statusMessage = ref('Waiting for a still.')
 const statusBusy = ref(false)
 const step = ref(0)
 const maxStep = ref(8)
+const chainStep = ref(1)
+const chainTotal = ref(1)
+const chainLabel = ref('')
 const elapsedMs = ref(0)
 const videoUrl = ref('')
 const jobId = ref('')
@@ -689,7 +764,9 @@ const extendPrompt = ref('')
 const extendDuration = ref(5)
 const lastFrameUrl = ref('')
 const lastFrameLoading = ref(false)
+const watchingLibrary = ref(false)
 let lastFrameObjectUrl = ''
+let lastFrameGen = 0
 const awaitingReveal = ref(false)
 const concealOutput = ref(false)
 const lockedSave = ref(false)
@@ -794,9 +871,16 @@ const currentClip = computed(() => clips.value.find(clip => clip.id === currentC
 const canExtend = computed(() => Boolean(
   videoUrl.value
   && !lockedSave.value
-  && !awaitingReveal.value
   && (currentClipId.value || clipIdFromPlayer())
 ))
+const extendSaveName = computed(() => nextClipPartName(currentClip.value?.name || currentClip.value?.prompt || ''))
+const queueReady = computed(() => extensionQueue.value.every(item => item.prompt.trim()))
+const generateLabel = computed(() => {
+  const n = extensionQueue.value.length
+  if (busy.value) return 'Generating…'
+  if (!n) return 'Generate Video'
+  return n === 1 ? 'Generate Initial + 1 Extension' : `Generate Initial + ${n} Extensions`
+})
 
 const visibleClips = computed(() => clips.value.filter(clip => clip.folderId === browseFolderId.value))
 const currentFolder = computed(() => folders.value.find(folder => folder.id === folderId.value))
@@ -1140,6 +1224,16 @@ function clipFileName(name: string) {
   return name.replace(/[<>:"/\\|?*'`]/g, '-').replace(/\s+/g, ' ').trim().slice(0, 80) || 'aigen'
 }
 
+function nextClipPartName(name: string) {
+  const trimmed = (name || '').trim()
+  if (!trimmed) return ''
+  const match = trimmed.match(/^(.*)\s+p(\d+)$/i)
+  const base = (match ? match[1] : trimmed).trim() || trimmed
+  const part = match ? Number(match[2]) + 1 : 2
+  const suffix = ` p${part}`
+  return `${base.slice(0, Math.max(1, 80 - suffix.length))}${suffix}`
+}
+
 function rerun(item: LibraryClip) {
   prompt.value = item.prompt
   clipName.value = item.name || ''
@@ -1162,6 +1256,11 @@ async function loadDraft(draft: RetryDraft) {
   if (draft.hideInput) hideInputPreview.value = true
   duration.value = clampDuration(Number(draft.duration))
   durationDraft.value = formatDuration(duration.value)
+  extensionQueue.value = (draft.extensions || []).slice(0, MAX_EXTENSIONS).map(item => ({
+    id: crypto.randomUUID(),
+    prompt: String(item.prompt || ''),
+    duration: item.duration === 3 ? 3 : 5 as 3 | 5
+  }))
   try {
     const blob = await $fetch<Blob>(`/api/library/drafts/${draft.id}/still`, { responseType: 'blob' })
     const filename = draft.stillFilename || 'held-still.png'
@@ -1228,6 +1327,7 @@ function clipVideoUrl(clipId: string) {
 }
 
 function closeExtend() {
+  lastFrameGen += 1
   extendOpen.value = false
   lastFrameLoading.value = false
   if (lastFrameObjectUrl) {
@@ -1237,37 +1337,43 @@ function closeExtend() {
   lastFrameUrl.value = ''
 }
 
-async function openExtend() {
-  const id = clipIdFromPlayer()
+async function openExtend(item?: LibraryClip) {
+  if (item) openClip(item)
+  const id = item?.id || clipIdFromPlayer()
   if (!id) {
     toast('Load a generated clip before extending it.')
     return
   }
   currentClipId.value = id
-  const clip = clips.value.find(item => item.id === id)
+  const clip = clips.value.find(entry => entry.id === id)
   extendPrompt.value = clip?.prompt || prompt.value
   extendDuration.value = 5
   extendOpen.value = true
   lastFrameLoading.value = true
   lastFrameUrl.value = ''
   player.value?.pause()
+  const gen = ++lastFrameGen
   try {
     const blob = await $fetch<Blob>(`/api/library/clips/${id}/last-frame`, { responseType: 'blob' })
+    if (gen !== lastFrameGen) return
     if (lastFrameObjectUrl) URL.revokeObjectURL(lastFrameObjectUrl)
     lastFrameObjectUrl = URL.createObjectURL(blob)
     lastFrameUrl.value = lastFrameObjectUrl
   } catch (error: any) {
+    if (gen !== lastFrameGen) return
     toast(error?.data?.statusMessage || 'Could not extract the last frame')
   } finally {
-    lastFrameLoading.value = false
+    if (gen === lastFrameGen) lastFrameLoading.value = false
   }
 }
 
 async function generateExtension() {
   const id = clipIdFromPlayer()
   if (!id || !extendPrompt.value.trim()) return
+  const switching = busy.value
   statusBusy.value = false
   busy.value = true
+  watchingLibrary.value = false
   listenGen += 1
   stopListen()
   settledUi = false
@@ -1275,6 +1381,9 @@ async function generateExtension() {
   awaitingReveal.value = false
   concealOutput.value = hideThumbnail.value || currentClip.value?.hideThumbnail === true
   lockedSave.value = false
+  chainStep.value = 1
+  chainTotal.value = 1
+  chainLabel.value = ''
   statusMessage.value = 'Extracting last frame & stitching extension...'
   startTimer()
   try {
@@ -1287,6 +1396,7 @@ async function generateExtension() {
       }
     })
     closeExtend()
+    if (switching) toast('Switched to this extension. The other job will keep saving to the library.')
     jobId.value = started.jobId
     maxStep.value = started.steps
     settledUi = false
@@ -1306,6 +1416,7 @@ async function generateExtension() {
 
 function openClip(item: LibraryClip) {
   closeExtend()
+  watchingLibrary.value = true
   currentClipId.value = item.id
   lockedSave.value = false
   concealOutput.value = item.hideThumbnail
@@ -1314,8 +1425,10 @@ function openClip(item: LibraryClip) {
   playerSize.value = { width: item.width || 1344, height: item.height || 768 }
   browseFolderId.value = item.folderId
   outputDownloadName.value = clipFileName(item.name || item.prompt.split(/[.!?\n]/)[0] || 'aigen')
-  statusMessage.value = item.hideThumbnail ? 'Hidden clip ready' : 'Loaded from library'
-  progress.value = 100
+  if (!busy.value) {
+    statusMessage.value = item.hideThumbnail ? 'Hidden clip ready' : 'Loaded from library'
+    progress.value = 100
+  }
 }
 
 async function removeClip(item: LibraryClip) {
@@ -1407,8 +1520,25 @@ function revealAndPlay() {
   })
 }
 
+function queueExtension() {
+  if (extensionQueue.value.length >= MAX_EXTENSIONS) return
+  extensionQueue.value.push({
+    id: crypto.randomUUID(),
+    prompt: prompt.value.trim(),
+    duration: 5
+  })
+}
+
+function removeQueuedExtension(id: string) {
+  extensionQueue.value = extensionQueue.value.filter(item => item.id !== id)
+}
+
 async function generate() {
   if (!file.value || !prompt.value.trim()) return
+  if (!queueReady.value) {
+    toast('Each queued extension needs a prompt.')
+    return
+  }
   if (!folderId.value) {
     toast('Choose a library folder before generating.')
     return
@@ -1425,8 +1555,12 @@ async function generate() {
   awaitingReveal.value = false
   concealOutput.value = hideThumbnail.value
   lockedSave.value = false
+  watchingLibrary.value = false
   playerSize.value = outputSize.value
   statusMessage.value = 'Checking ComfyUI...'
+  chainStep.value = 1
+  chainTotal.value = 1 + extensionQueue.value.length
+  chainLabel.value = extensionQueue.value.length ? 'Initial' : ''
   startTimer()
   try {
     const body = new FormData()
@@ -1449,6 +1583,12 @@ async function generate() {
     body.append('sound', String(withSound.value))
     body.append('name', clipName.value.trim())
     if (activeDraftId) body.append('draftId', activeDraftId)
+    if (extensionQueue.value.length) {
+      body.append('extensions', JSON.stringify(extensionQueue.value.map(item => ({
+        prompt: item.prompt.trim(),
+        duration: item.duration
+      }))))
+    }
     outputDownloadName.value = clipFileName(clipName.value.trim() || prompt.value.trim().split(/[.!?\n]/)[0] || 'aigen')
     const started = await $fetch<{ jobId: string; seed: number; width: number; height: number; steps: number; turbo: boolean; hideThumbnail?: boolean; folderLocked?: boolean }>('/api/generate', {
       method: 'POST',
@@ -1490,6 +1630,9 @@ function applyJobEvent(payload: Record<string, any>, hidden: boolean, folderLock
   if (typeof payload.progress === 'number') progress.value = payload.progress
   if (typeof payload.step === 'number') step.value = payload.step
   if (typeof payload.maxStep === 'number') maxStep.value = payload.maxStep
+  if (typeof payload.chainStep === 'number') chainStep.value = payload.chainStep
+  if (typeof payload.chainTotal === 'number') chainTotal.value = payload.chainTotal
+  if (payload.chainLabel) chainLabel.value = String(payload.chainLabel)
 
   const failed = payload.type === 'error' || payload.status === 'error' || payload.status === 'cancelled'
   const complete = payload.type === 'complete' || payload.status === 'complete'
@@ -1515,6 +1658,22 @@ function applyJobEvent(payload: Record<string, any>, hidden: boolean, folderLock
     const locked = dest
       ? Boolean(dest.protected && !dest.unlocked)
       : (folderLocked || payload.folderLocked === true)
+    const keepLibraryView = watchingLibrary.value && Boolean(currentClipId.value) && payload.clipId !== currentClipId.value
+    if (keepLibraryView) {
+      busy.value = false
+      statusBusy.value = false
+      stopTimer()
+      stopListen()
+      clearActiveJob()
+      activeDraftId = ''
+      loadLibrary().catch(() => null)
+      void pollComfyHealth()
+      statusMessage.value = currentClip.value?.hideThumbnail ? 'Hidden clip ready' : 'Loaded from library'
+      toast(locked
+        ? 'Saved to the locked folder. Unlock it to view.'
+        : 'New clip saved to the library')
+      return
+    }
     if (locked) {
       videoUrl.value = ''
       awaitingReveal.value = false
diff --git a/server/api/extend.post.ts b/server/api/extend.post.ts
index e80317d..e5189b3 100644
--- a/server/api/extend.post.ts
+++ b/server/api/extend.post.ts
@@ -68,7 +68,7 @@ export default defineEventHandler(async (event) => {
   const length = frameLength(durationSeconds, fps)
   const width = source.width || 1344
   const height = source.height || 768
-  const clipName = `${clipTitle(source)} extended`.slice(0, 80)
+  const clipName = nextClipPartName(clipTitle(source))
 
   const job = createJob()
   job.maxStep = steps
diff --git a/server/api/generate.post.ts b/server/api/generate.post.ts
index 9813837..141729b 100644
--- a/server/api/generate.post.ts
+++ b/server/api/generate.post.ts
@@ -1,3 +1,6 @@
+import { copyFileSync, readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
 function isComfyBusyTimeout(error: unknown) {
   const err = error as { statusCode?: number; status?: number; data?: { code?: string }; message?: string; statusMessage?: string }
   if (err?.statusCode === 409 || err?.status === 409 || err?.data?.code === 'COMFY_BUSY') return true
@@ -11,6 +14,28 @@ function parseDuration(raw: string) {
   return Math.min(120, Math.max(0.5, seconds))
 }
 
+function parseExtendDuration(raw: unknown) {
+  const seconds = Number(raw)
+  return seconds === 3 || seconds === 5 ? seconds : 5
+}
+
+function parseExtensions(raw: string | undefined) {
+  if (!raw) return [] as { prompt: string; duration: number }[]
+  try {
+    const parsed = JSON.parse(raw)
+    if (!Array.isArray(parsed)) return []
+    return parsed
+      .slice(0, 8)
+      .map((item: { prompt?: unknown; duration?: unknown }) => ({
+        prompt: String(item?.prompt || '').trim(),
+        duration: parseExtendDuration(item?.duration)
+      }))
+      .filter(item => item.prompt)
+  } catch {
+    return []
+  }
+}
+
 const SAMPLERS = new Set(['res_multistep', 'euler', 'dpmpp_2m'])
 const SCHEDULERS = new Set(['simple', 'ddim_uniform', 'sgm_uniform'])
 
@@ -39,6 +64,19 @@ function parseScheduler(raw: string | undefined) {
   return SCHEDULERS.has(raw || '') ? raw! : 'simple'
 }
 
+function sleep(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function assertJobActive(job: ReturnType<typeof createJob>) {
+  if (job.status === 'cancelled') {
+    throw new Error('Job interrupted.')
+  }
+  if (job.status === 'error') {
+    throw new Error(job.error || 'Generation failed')
+  }
+}
+
 export default defineEventHandler(async (event) => {
   const form = await readMultipartFormData(event)
   if (!form?.length) {
@@ -62,6 +100,7 @@ export default defineEventHandler(async (event) => {
   if (!prompt) {
     throw createError({ statusCode: 400, statusMessage: 'A motion prompt is required' })
   }
+  const extensions = parseExtensions(fields.extensions)
 
   const { width, height } = resolveOutputSize(fields.aspect, image.data, Number(fields.width), Number(fields.height))
   const turbo = fields.turbo !== 'false'
@@ -100,6 +139,7 @@ export default defineEventHandler(async (event) => {
     hideInput
   })
 
+  const chainTotal = 1 + extensions.length
   const job = createJob()
   job.maxStep = steps
   job.hideThumbnail = hideThumbnail
@@ -126,11 +166,32 @@ export default defineEventHandler(async (event) => {
     stillFilename: still.filename,
     duration: durationSeconds,
     sound,
-    draftId: (fields.draftId || '').trim() || undefined
+    draftId: (fields.draftId || '').trim() || undefined,
+    extensions,
+    chainIndex: 0,
+    chainStep: 1,
+    chainTotal,
+    chainLabel: extensions.length ? 'Initial' : undefined
   }
-  emitJob(job, { type: 'status', message: 'Checking ComfyUI...', progress: 1 })
+  emitChainJob(job, { type: 'status', message: 'Checking ComfyUI...', progress: 1 })
 
-  void runGeneration(job, { prompt, image, width, height, steps, seed, turbo, length, sound, cfg, fps, samplerName, scheduler }).catch(async (error) => {
+  void runGeneration(job, {
+    prompt,
+    image,
+    width,
+    height,
+    steps,
+    seed,
+    turbo,
+    length,
+    sound,
+    cfg,
+    fps,
+    samplerName,
+    scheduler,
+    extensions
+  }).catch(async (error) => {
+    removeExtendTemp(job.library?.extendTmpDir)
     if (isComfyBusyTimeout(error) && job.library) {
       try {
         const draft = await saveRetryDraft({
@@ -154,7 +215,8 @@ export default defineEventHandler(async (event) => {
           cfg: job.library.cfg,
           fps: job.library.fps,
           samplerName: job.library.samplerName,
-          scheduler: job.library.scheduler
+          scheduler: job.library.scheduler,
+          extensions: job.library.extensions
         })
         job.library.draftId = draft.id
         job.status = 'deferred'
@@ -165,6 +227,7 @@ export default defineEventHandler(async (event) => {
         // fall through to a normal error if the held job could not be saved
       }
     }
+    if (job.status === 'error' || job.status === 'cancelled' || job.status === 'deferred') return
     const message = error instanceof Error ? error.message : String(error)
     job.status = 'error'
     job.error = message
@@ -186,48 +249,53 @@ export default defineEventHandler(async (event) => {
     turbo,
     folderId,
     hideThumbnail,
-    folderLocked
+    folderLocked,
+    chainTotal
   }
 })
 
-async function runGeneration(
-  job: ReturnType<typeof createJob>,
-  params: {
-    prompt: string
-    image: { filename: string; data: Buffer; type?: string }
-    width: number
-    height: number
-    steps: number
-    seed: number
-    turbo: boolean
-    length: number
-    sound: boolean
-    cfg: number
-    fps: number
-    samplerName: string
-    scheduler: string
-  }
-) {
-  await ensureComfyReady((status) => {
-    emitJob(job, {
-      type: status.state === 'busy' ? 'busy' : 'status',
-      message: status.message,
-      progress: status.state === 'online' ? Math.max(job.progress, 3) : Math.max(job.progress, 1),
-      busy: status.state === 'busy',
-      queueRunning: status.queueRunning,
-      queuePending: status.queuePending
-    })
-  })
+type GenerateParams = {
+  prompt: string
+  image: { filename: string; data: Buffer; type?: string }
+  width: number
+  height: number
+  steps: number
+  seed: number
+  turbo: boolean
+  length: number
+  sound: boolean
+  cfg: number
+  fps: number
+  samplerName: string
+  scheduler: string
+  extensions: { prompt: string; duration: number }[]
+}
 
-  const done = watchComfyJob(job)
+async function queueMiniMax(
+  job: ReturnType<typeof createJob>,
+  params: Omit<GenerateParams, 'extensions'> & { persist: boolean }
+) {
+  assertJobActive(job)
+  job.socketReady = false
+  job.promptId = undefined
+  job.video = undefined
+  job.segmentBuffer = undefined
+
+  const done = watchComfyJob(job, { persist: params.persist })
   job.status = 'uploading'
-  emitJob(job, { type: 'status', message: 'Uploading image to ComfyUI...', progress: 4 })
+  const uploading = (job.library?.chainIndex || 0) > 0
+    ? 'Uploading last frame to ComfyUI...'
+    : 'Uploading image to ComfyUI...'
+  const queueing = (job.library?.chainIndex || 0) > 0
+    ? 'Queueing extension on MiniMax H3...'
+    : 'Queueing MiniMax H3 job...'
+  emitChainJob(job, { type: 'status', message: uploading, progress: 4 })
   const uploaded = await uploadImage(params.image, job.id)
   if (job.library) {
     job.library.imageName = uploaded.name
     job.library.imageSubfolder = uploaded.subfolder
   }
-  emitJob(job, { type: 'status', message: 'Queueing MiniMax H3 job...', progress: 6 })
+  emitChainJob(job, { type: 'status', message: queueing, progress: 6 })
   await waitForComfySocket(job, 4000)
 
   const graph = buildWorkflow({
@@ -278,6 +346,92 @@ async function runGeneration(
       extendPart1Path: job.library.extendPart1Path
     })
   }
-  emitJob(job, { type: 'status', message: 'Job queued on ComfyUI', progress: 8 })
+  emitChainJob(job, { type: 'status', message: 'Job queued on ComfyUI', progress: 8 })
   await done
+  assertJobActive(job)
+  if (!params.persist && !job.segmentBuffer?.length) {
+    throw new Error('Segment finished without a video')
+  }
+}
+
+async function runGeneration(
+  job: ReturnType<typeof createJob>,
+  params: GenerateParams
+) {
+  const ready = (status: { state: string; message: string; queueRunning?: number; queuePending?: number }) => {
+    emitChainJob(job, {
+      type: status.state === 'busy' ? 'busy' : 'status',
+      message: status.message,
+      progress: status.state === 'online' ? 3 : 1,
+      busy: status.state === 'busy',
+      queueRunning: status.queueRunning,
+      queuePending: status.queuePending
+    })
+  }
+
+  await ensureComfyReady(ready)
+
+  const { extensions, ...base } = params
+  await queueMiniMax(job, {
+    ...base,
+    persist: extensions.length === 0
+  })
+
+  if (!extensions.length || !job.library) return
+
+  const tmpDir = extendTempDir(job.library.ownerKey, job.id)
+  job.library.extendTmpDir = tmpDir
+  const currentPath = join(tmpDir, 'current.mp4')
+  const part1Path = join(tmpDir, 'part1.mp4')
+  const framePath = join(tmpDir, 'last_frame.png')
+  writeFileSync(currentPath, job.segmentBuffer!)
+  job.segmentBuffer = undefined
+
+  for (let i = 0; i < extensions.length; i++) {
+    assertJobActive(job)
+    const ext = extensions[i]
+    const isLast = i === extensions.length - 1
+    job.library.chainIndex = i + 1
+    job.library.chainStep = i + 2
+    job.library.chainLabel = `Extension ${i + 1}`
+    job.library.extendPart1Path = undefined
+
+    emitChainJob(job, { type: 'status', message: 'Waiting 3s buffer...', progress: 1 })
+    await sleep(3000)
+    assertJobActive(job)
+
+    copyFileSync(currentPath, part1Path)
+    await extractLastFrame(part1Path, framePath)
+    const frame = readFileSync(framePath)
+    job.library.extendPart1Path = part1Path
+    const sound = await probeHasAudio(currentPath)
+    const seed = Math.floor(Math.random() * 2_147_483_647)
+
+    await ensureComfyReady(ready)
+    await queueMiniMax(job, {
+      prompt: ext.prompt,
+      image: { filename: 'last_frame.png', data: frame, type: 'image/png' },
+      width: params.width,
+      height: params.height,
+      steps: params.steps,
+      seed,
+      turbo: params.turbo,
+      length: frameLength(ext.duration, params.fps),
+      sound,
+      cfg: params.cfg,
+      fps: params.fps,
+      samplerName: params.samplerName,
+      scheduler: params.scheduler,
+      persist: isLast
+    })
+
+    if (!isLast) {
+      if (!job.segmentBuffer?.length) {
+        throw new Error('Extension finished without a stitched video')
+      }
+      writeFileSync(currentPath, job.segmentBuffer)
+      job.segmentBuffer = undefined
+      job.library.extendPart1Path = undefined
+    }
+  }
 }
diff --git a/server/utils/ffmpeg.ts b/server/utils/ffmpeg.ts
index 0c53885..d21ed11 100644
--- a/server/utils/ffmpeg.ts
+++ b/server/utils/ffmpeg.ts
@@ -92,6 +92,132 @@ export async function probeHasAudio(filePath: string) {
   }
 }
 
+const XFADE_DURATION = 0.12
+
+async function probeDuration(filePath: string) {
+  const out = await runFfprobe([
+    '-v', 'error',
+    '-show_entries', 'format=duration',
+    '-of', 'default=nokey=1:noprint_wrappers=1',
+    filePath
+  ])
+  const duration = Number(out)
+  if (!Number.isFinite(duration) || duration <= 0) {
+    throw new Error('Could not read video duration')
+  }
+  return duration
+}
+
+async function probeFps(filePath: string) {
+  const out = await runFfprobe([
+    '-v', 'error',
+    '-select_streams', 'v:0',
+    '-show_entries', 'stream=avg_frame_rate,r_frame_rate',
+    '-of', 'default=nokey=1:noprint_wrappers=1',
+    filePath
+  ])
+  const line = out.split(/\r?\n/).map(item => item.trim()).find(Boolean) || ''
+  const [num, den] = line.split('/').map(Number)
+  if (Number.isFinite(num) && Number.isFinite(den) && den > 0) return num / den
+  const fps = Number(line)
+  return Number.isFinite(fps) && fps > 0 ? fps : 24
+}
+
+async function probeSize(filePath: string) {
+  const out = await runFfprobe([
+    '-v', 'error',
+    '-select_streams', 'v:0',
+    '-show_entries', 'stream=width,height',
+    '-of', 'csv=p=0',
+    filePath
+  ])
+  const [width, height] = out.split(',').map(Number)
+  return {
+    width: Number.isFinite(width) && width > 0 ? width : 1344,
+    height: Number.isFinite(height) && height > 0 ? height : 768
+  }
+}
+
+async function trimLeadingFrame(inputPath: string, outputPath: string) {
+  const fps = await probeFps(inputPath)
+  const hasAudio = await probeHasAudio(inputPath)
+  const args = [
+    '-y',
+    '-i', inputPath,
+    '-vf', 'trim=start_frame=1,setpts=PTS-STARTPTS'
+  ]
+  if (hasAudio) {
+    args.push('-af', `atrim=start=${(1 / fps).toFixed(6)},asetpts=PTS-STARTPTS`, '-c:a', 'aac')
+  } else {
+    args.push('-an')
+  }
+  args.push(
+    '-c:v', 'libx264',
+    '-preset', 'fast',
+    '-crf', '17',
+    '-pix_fmt', 'yuv420p',
+    '-movflags', '+faststart',
+    outputPath
+  )
+  await runFfmpeg(args, 180000)
+  if (!existsSync(outputPath)) {
+    throw new Error('FFmpeg did not write the trimmed extension segment')
+  }
+}
+
+async function xfadeStitch(part1Path: string, part2Path: string, outputPath: string) {
+  const [duration1, duration2, fps, size, audio1, audio2] = await Promise.all([
+    probeDuration(part1Path),
+    probeDuration(part2Path),
+    probeFps(part1Path),
+    probeSize(part1Path),
+    probeHasAudio(part1Path),
+    probeHasAudio(part2Path)
+  ])
+  const fade = Math.min(
+    XFADE_DURATION,
+    Math.max(0.04, duration1 - 0.05),
+    Math.max(0.04, duration2 - 0.05)
+  )
+  const offset = Math.max(0, Number((duration1 - fade).toFixed(3)))
+  const fpsLabel = Number.isInteger(fps) ? String(fps) : fps.toFixed(3)
+  const prepare = `fps=${fpsLabel},scale=${size.width}:${size.height}:flags=bicubic,format=yuv420p,setpts=PTS-STARTPTS`
+  const videoFilter = `[0:v]${prepare}[v0];[1:v]${prepare}[v1];[v0][v1]xfade=transition=fade:duration=${fade.toFixed(3)}:offset=${offset},setpts=PTS-STARTPTS[v]`
+  const encode = [
+    '-c:v', 'libx264',
+    '-preset', 'fast',
+    '-crf', '17',
+    '-pix_fmt', 'yuv420p',
+    '-movflags', '+faststart'
+  ]
+  if (audio1 && audio2) {
+    await runFfmpeg([
+      '-y',
+      '-i', part1Path,
+      '-i', part2Path,
+      '-filter_complex', `${videoFilter};[0:a]asetpts=PTS-STARTPTS[a0];[1:a]asetpts=PTS-STARTPTS[a1];[a0][a1]acrossfade=d=${fade.toFixed(3)}:c1=tri:c2=tri[a]`,
+      '-map', '[v]',
+      '-map', '[a]',
+      ...encode,
+      '-c:a', 'aac',
+      outputPath
+    ], 300000)
+  } else {
+    await runFfmpeg([
+      '-y',
+      '-i', part1Path,
+      '-i', part2Path,
+      '-filter_complex', videoFilter,
+      '-map', '[v]',
+      ...encode,
+      outputPath
+    ], 300000)
+  }
+  if (!existsSync(outputPath)) {
+    throw new Error('FFmpeg did not write the blended video')
+  }
+}
+
 export async function concatMp4(part1Path: string, part2Path: string, outputPath: string) {
   const listPath = join(dirname(outputPath), 'concat_list.txt')
   writeFileSync(listPath, `file '${concatPath(part1Path)}'\nfile '${concatPath(part2Path)}'\n`)
@@ -111,7 +237,7 @@ export async function concatMp4(part1Path: string, part2Path: string, outputPath
           '-map', '[a]',
           '-c:v', 'libx264',
           '-preset', 'fast',
-          '-crf', '18',
+          '-crf', '17',
           '-pix_fmt', 'yuv420p',
           '-c:a', 'aac',
           '-movflags', '+faststart',
@@ -126,7 +252,7 @@ export async function concatMp4(part1Path: string, part2Path: string, outputPath
           '-map', '[v]',
           '-c:v', 'libx264',
           '-preset', 'fast',
-          '-crf', '18',
+          '-crf', '17',
           '-pix_fmt', 'yuv420p',
           '-movflags', '+faststart',
           outputPath
@@ -145,11 +271,24 @@ export async function concatMp4(part1Path: string, part2Path: string, outputPath
 
 export async function stitchExtension(params: { part1Path: string; part2: Buffer; tmpDir: string }) {
   const part2Path = join(params.tmpDir, 'part2.mp4')
+  const trimmedPath = join(params.tmpDir, 'part2_trim.mp4')
   const finalPath = join(params.tmpDir, 'final_stitched_video.mp4')
   writeFileSync(part2Path, params.part2)
-  await concatMp4(params.part1Path, part2Path, finalPath)
+  try {
+    await trimLeadingFrame(part2Path, trimmedPath)
+    await xfadeStitch(params.part1Path, trimmedPath, finalPath)
+  } catch (blendError) {
+    try {
+      const trimmedReady = existsSync(trimmedPath)
+      await concatMp4(params.part1Path, trimmedReady ? trimmedPath : part2Path, finalPath)
+    } catch (concatError) {
+      const blendMessage = blendError instanceof Error ? blendError.message : String(blendError)
+      const concatMessage = concatError instanceof Error ? concatError.message : String(concatError)
+      throw new Error(`Seam blend failed (${blendMessage}). Concat fallback also failed (${concatMessage}).`)
+    }
+  }
   const stitched = readFileSync(finalPath)
-  for (const extra of [part2Path, join(params.tmpDir, 'concat_list.txt'), join(params.tmpDir, 'last_frame.png')]) {
+  for (const extra of [part2Path, trimmedPath, join(params.tmpDir, 'concat_list.txt'), join(params.tmpDir, 'last_frame.png')]) {
     try { unlinkSync(extra) } catch { /* ignore */ }
   }
   return stitched
diff --git a/server/utils/jobs.ts b/server/utils/jobs.ts
index badb210..67b34a8 100644
--- a/server/utils/jobs.ts
+++ b/server/utils/jobs.ts
@@ -20,6 +20,9 @@ export interface JobEvent {
   folderLocked?: boolean
   jobId?: string
   draftId?: string
+  chainStep?: number
+  chainTotal?: number
+  chainLabel?: string
 }
 
 export interface Job {
@@ -61,12 +64,18 @@ export interface Job {
     duration?: number
     sound?: boolean
     draftId?: string
+    extensions?: { prompt: string; duration: number }[]
+    chainIndex?: number
+    chainStep?: number
+    chainTotal?: number
+    chainLabel?: string
     extendTmpDir?: string
     extendPart1Path?: string
     extendSourceClipId?: string
   }
   error?: string
   socketReady?: boolean
+  segmentBuffer?: Buffer
   events: JobEvent[]
   listeners: Set<(event: JobEvent) => void>
 }
@@ -121,7 +130,10 @@ export function jobSnapshot(job: Job) {
     hideThumbnail: job.hideThumbnail,
     error: job.error,
     folderLocked: job.library?.folderLocked,
-    draftId: job.library?.draftId
+    draftId: job.library?.draftId,
+    chainStep: job.library?.chainStep,
+    chainTotal: job.library?.chainTotal,
+    chainLabel: job.library?.chainLabel
   }
 }
 
@@ -131,6 +143,13 @@ export function emitJob(job: Job, event: JobEvent) {
   if (typeof event.progress === 'number') job.progress = event.progress
   if (typeof event.step === 'number') job.step = event.step
   if (typeof event.maxStep === 'number') job.maxStep = event.maxStep
+  if (typeof event.chainStep === 'number') {
+    if (job.library) job.library.chainStep = event.chainStep
+  }
+  if (typeof event.chainTotal === 'number') {
+    if (job.library) job.library.chainTotal = event.chainTotal
+  }
+  if (event.chainLabel && job.library) job.library.chainLabel = event.chainLabel
   event.elapsedMs = Date.now() - job.startedAt
   job.events.push(event)
   if (job.events.length > 200) job.events.shift()
diff --git a/server/utils/library.ts b/server/utils/library.ts
index 7789a80..f9853ab 100644
--- a/server/utils/library.ts
+++ b/server/utils/library.ts
@@ -57,6 +57,11 @@ export interface PublicFolder {
   clipCount: number
 }
 
+export interface QueuedExtension {
+  prompt: string
+  duration: number
+}
+
 export interface RetryDraft {
   id: string
   createdAt: number
@@ -79,6 +84,7 @@ export interface RetryDraft {
   fps?: number
   samplerName?: string
   scheduler?: string
+  extensions?: QueuedExtension[]
 }
 
 interface Catalog {
@@ -198,11 +204,15 @@ function ensureOwner(owner: string) {
 
 function readCatalog(owner: string): Catalog {
   ensureOwner(owner)
+  const path = catalogPath(owner)
   try {
-    return normalizeCatalog(JSON.parse(readFileSync(catalogPath(owner), 'utf8')))
+    return normalizeCatalog(JSON.parse(readFileSync(path, 'utf8')))
   } catch {
+    if (existsSync(path)) {
+      throw createError({ statusCode: 500, statusMessage: 'Library catalog could not be read' })
+    }
     const created = emptyCatalog()
-    writeFileSync(catalogPath(owner), JSON.stringify(created, null, 2))
+    writeFileSync(path, JSON.stringify(created, null, 2))
     return created
   }
 }
@@ -233,6 +243,16 @@ export function clipTitle(clip: Pick<LibraryClip, 'name' | 'prompt'>) {
   return fromPrompt || 'Untitled clip'
 }
 
+export function nextClipPartName(name: string) {
+  const trimmed = (name || '').trim()
+  if (!trimmed) return ''
+  const match = trimmed.match(/^(.*)\s+p(\d+)$/i)
+  const base = (match ? match[1] : trimmed).trim() || trimmed
+  const part = match ? Number(match[2]) + 1 : 2
+  const suffix = ` p${part}`
+  return `${base.slice(0, Math.max(1, 80 - suffix.length))}${suffix}`
+}
+
 export function safeDownloadName(name: string) {
   const cleaned = name.replace(/[<>:"/\\|?*'`\u0000-\u001f]/g, '-').replace(/\s+/g, ' ').trim()
   return cleaned.slice(0, 80) || 'aigen'
@@ -689,6 +709,7 @@ export async function saveRetryDraft(params: {
   fps?: number
   samplerName?: string
   scheduler?: string
+  extensions?: QueuedExtension[]
 }) {
   return mutate(params.ownerKey, (catalog) => {
     const existing = params.id ? catalog.drafts.find(item => item.id === params.id) : undefined
@@ -713,7 +734,8 @@ export async function saveRetryDraft(params: {
       cfg: params.cfg,
       fps: params.fps,
       samplerName: params.samplerName,
-      scheduler: params.scheduler
+      scheduler: params.scheduler,
+      extensions: params.extensions?.length ? params.extensions : undefined
     }
     catalog.drafts = [draft, ...catalog.drafts.filter(item => item.id !== draft.id)].slice(0, 20)
     return draft
diff --git a/server/utils/watch.ts b/server/utils/watch.ts
index a8248d9..73d72de 100644
--- a/server/utils/watch.ts
+++ b/server/utils/watch.ts
@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs'
-import type { Job } from '~/server/utils/jobs'
+import type { Job, JobEvent } from '~/server/utils/jobs'
 
 function classifyError(message: string) {
   const lower = message.toLowerCase()
@@ -19,13 +19,71 @@ function sleep(ms: number) {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
 
-export function watchComfyJob(job: Job): Promise<void> {
+function chainMeta(job: Job) {
+  const total = Math.max(1, job.library?.chainTotal || 1)
+  const index = job.library?.chainIndex ?? 0
+  return {
+    total,
+    index,
+    step: index + 1,
+    label: job.library?.chainLabel || (index === 0 ? 'Initial' : `Extension ${index}`),
+    chained: total > 1
+  }
+}
+
+export function mapChainProgress(job: Job, localPct: number) {
+  const { total, index, chained } = chainMeta(job)
+  const local = Math.max(0, Math.min(100, localPct))
+  if (!chained) return Math.round(local)
+  const share = 100 / total
+  return Math.min(99, Math.round(index * share + (Math.min(local, 99) / 100) * share))
+}
+
+export function formatChainMessage(job: Job, message: string, samplePct?: number) {
+  const { chained, step, total, label } = chainMeta(job)
+  if (!chained) return message
+  if (typeof samplePct === 'number') {
+    return `Step ${step}/${total}: Generating ${label} (${samplePct}%)`
+  }
+  if (/waiting 3s buffer/i.test(message)) {
+    return `Step ${step}/${total}: Waiting 3s buffer...`
+  }
+  return `Step ${step}/${total}: ${message}`
+}
+
+export function emitChainJob(job: Job, event: JobEvent, samplePct?: number) {
+  const { chained, step, total, label } = chainMeta(job)
+  const next: JobEvent = { ...event }
+  if (next.message) {
+    next.message = formatChainMessage(job, next.message, samplePct)
+  }
+  if (chained && typeof next.progress === 'number' && next.type !== 'complete') {
+    next.progress = mapChainProgress(job, next.progress)
+  }
+  if (chained) {
+    next.chainStep = step
+    next.chainTotal = total
+    next.chainLabel = label
+  }
+  emitJob(job, next)
+}
+
+export function watchComfyJob(job: Job, options: { persist?: boolean } = {}): Promise<void> {
+  const persist = options.persist !== false
+  job.socketReady = false
   const ws = new WebSocket(comfyWsUrl(job.clientId))
   let settled = false
   let pollTimer: ReturnType<typeof setInterval> | null = null
   let timeout: ReturnType<typeof setTimeout> | null = null
 
   return new Promise((resolve) => {
+    let localProgress = 0
+
+    const emitLocal = (event: JobEvent, samplePct?: number) => {
+      if (typeof event.progress === 'number') localProgress = event.progress
+      emitChainJob(job, event, samplePct)
+    }
+
     const cleanup = () => {
       if (timeout) clearTimeout(timeout)
       if (pollTimer) clearInterval(pollTimer)
@@ -40,7 +98,7 @@ export function watchComfyJob(job: Job): Promise<void> {
       cleanup()
       job.status = job.status === 'cancelled' ? 'cancelled' : 'error'
       job.error = classifyError(error)
-      emitJob(job, { type: 'error', error: job.error, message: job.error })
+      emitChainJob(job, { type: 'error', error: job.error, message: job.error })
       if (job.id) deletePendingJob(job.id)
       removeExtendTemp(job.library?.extendTmpDir)
       resolve()
@@ -56,9 +114,9 @@ export function watchComfyJob(job: Job): Promise<void> {
       try {
         job.video = video
         const stitching = Boolean(job.library?.extendPart1Path && job.library.extendTmpDir)
-        emitJob(job, {
+        emitLocal({
           type: 'status',
-          message: stitching ? 'Extracting last frame & stitching extension...' : 'Saving to library...',
+          message: stitching ? 'Extracting last frame & stitching extension...' : (persist ? 'Saving to library...' : 'Downloading segment...'),
           progress: stitching ? 97 : 98
         })
         if (job.library) {
@@ -73,6 +131,23 @@ export function watchComfyJob(job: Job): Promise<void> {
               tmpDir: job.library.extendTmpDir!
             })
           }
+          if (!persist) {
+            job.segmentBuffer = buffer
+            await purgeComfyArtifacts({
+              video,
+              imageName: job.library.imageName,
+              imageSubfolder: job.library.imageSubfolder,
+              promptId: job.promptId
+            })
+            deletePendingJob(job.id)
+            emitLocal({
+              type: 'status',
+              message: stitching ? 'Extension stitched' : 'Initial segment ready',
+              progress: 99
+            })
+            resolve()
+            return true
+          }
           const clip = await saveClip({
             ownerKey: job.library.ownerKey,
             folderId: job.library.folderId,
@@ -111,22 +186,27 @@ export function watchComfyJob(job: Job): Promise<void> {
           type: 'complete',
           message: job.library?.folderLocked
             ? 'Saved to the locked folder. Unlock it to view.'
-            : (job.library?.extendSourceClipId ? 'Extended video ready' : 'Video ready'),
+            : (job.library?.extendSourceClipId || (job.library?.chainTotal || 1) > 1 ? 'Extended video ready' : 'Video ready'),
           progress: 100,
           filename: job.library?.folderLocked ? undefined : video.filename,
           subfolder: job.library?.folderLocked ? undefined : video.subfolder,
           mediaType: job.library?.folderLocked ? undefined : video.type,
           clipId: job.clipId,
           hideThumbnail: job.hideThumbnail,
-          folderLocked: job.library?.folderLocked
+          folderLocked: job.library?.folderLocked,
+          chainStep: job.library?.chainStep,
+          chainTotal: job.library?.chainTotal,
+          chainLabel: job.library?.chainLabel
         })
         deletePendingJob(job.id)
       } catch (saveError) {
         removeExtendTemp(job.library?.extendTmpDir)
         const message = saveError instanceof Error ? saveError.message : String(saveError)
         job.status = 'error'
-        job.error = `Video generated but library save failed: ${message}`
-        emitJob(job, { type: 'error', error: job.error, message: job.error })
+        job.error = persist
+          ? `Video generated but library save failed: ${message}`
+          : `Segment finished but could not be prepared: ${message}`
+        emitChainJob(job, { type: 'error', error: job.error, message: job.error })
       }
       resolve()
       return true
@@ -169,7 +249,7 @@ export function watchComfyJob(job: Job): Promise<void> {
 
     ws.addEventListener('open', () => {
       job.socketReady = true
-      emitJob(job, { type: 'status', message: 'Connected to ComfyUI', progress: Math.max(job.progress, 4) })
+      emitLocal({ type: 'status', message: 'Connected to ComfyUI', progress: Math.max(localProgress, 4) })
     })
 
     ws.addEventListener('close', () => {
@@ -191,15 +271,16 @@ export function watchComfyJob(job: Job): Promise<void> {
         const value = Number(data.value || 0)
         const max = Number(data.max || 1)
         const pct = 12 + Math.round((value / Math.max(max, 1)) * 70)
+        const samplePct = Math.round((value / Math.max(max, 1)) * 100)
         job.status = 'running'
-        emitJob(job, {
+        emitLocal({
           type: 'progress',
           step: value,
           maxStep: max,
           progress: pct,
           node: data.node ? String(data.node) : null,
-          message: `Sampling step ${value}/${max} (${Math.round((value / Math.max(max, 1)) * 100)}%)`
-        })
+          message: `Sampling step ${value}/${max} (${samplePct}%)`
+        }, samplePct)
       }
 
       if (payload.type === 'executing') {
@@ -207,16 +288,16 @@ export function watchComfyJob(job: Job): Promise<void> {
         if (node === null) {
           const saved = await succeed()
           if (!saved) {
-            emitJob(job, { type: 'status', message: 'Waiting for ComfyUI to save the MP4...', progress: 96 })
+            emitLocal({ type: 'status', message: 'Waiting for ComfyUI to save the MP4...', progress: 96 })
           }
           return
         }
         const label = NODE_LABELS[node] || `Running node ${node}`
         const encoding = isEncodingNode(node)
-        emitJob(job, {
+        emitLocal({
           type: 'executing',
           node,
-          progress: encoding ? 90 : Math.max(job.progress, 10),
+          progress: encoding ? 90 : Math.max(localProgress, 10),
           message: encoding ? 'Encoding video...' : `${label}...`
         })
       }