@lightcone-ai/daemon 0.18.0 → 0.18.1

package/mcp-servers/official/media-tools/index.js

@@ -278,9 +278,10 @@ server.tool(
   + 'When any segment has audio_path, MUST be preceded by plan_video_segments in the same session '
   + '(plan_video_segments fills duration/subtitle_text/audio_path mechanically; manual alignment is rejected). '
   + 'Returns a local mp4 path + size_bytes.\n\n'
-  + 'Dual-version delivery (subtitled + clean): call this tool twice with the SAME segments — first with default '
-  + 'burn_subtitles=true (or omitted), then again with burn_subtitles=false and a different output_path. Only the '
-  + 'final ffmpeg pass repeats; audio, source clips, and the plan_video_segments alignment are all reused.',
+  + 'Dual / multi-version delivery (e.g. subtitled+voiced + clean silent): pass the variants[] array — one call '
+  + 'runs the heavy per-segment ffmpeg work ONCE and only diverges at audio mux + concat + subtitle burn per '
+  + 'variant. That is ~1.2-1.4× single-version time vs ~2× when calling this tool twice. Each variant chooses '
+  + 'its own burn_subtitles and include_audio independently.',
   {
     segments: z.array(z.object({
       visual_path: z.string().optional().describe('Absolute path to a single image / video / gif.'),
@@ -297,10 +298,18 @@ server.tool(
     })).describe('Ordered list of video segments.'),
     outro_paths: z.array(z.string()).optional().describe('Absolute paths to outro video clips appended at end.'),
     resolution: z.string().optional().describe('Output resolution WxH. Default "1080x1920".'),
-    output_path: z.string().optional().describe('Absolute output path. Auto-generated if omitted.'),
-    burn_subtitles: z.boolean().optional().describe('Whether to burn subtitle_text into the video. Default true. '
-      + 'Pass false to produce a clean no-subtitle copy (dual-version delivery: run compose_video_v2 twice — '
-      + 'once with default true, once with false + a different output_path — same segments, only one extra ffmpeg pass).'),
+    output_path: z.string().optional().describe('Absolute output path (single-output mode). Auto-generated if omitted. Ignored when variants[] is provided.'),
+    burn_subtitles: z.boolean().optional().describe('Single-output mode only: whether to burn subtitle_text. Default true. '
+      + 'For producing multiple variants in one call, use variants[] instead.'),
+    variants: z.array(z.object({
+      output_path: z.string().describe('Absolute output path for this variant. Each variant must use a unique path.'),
+      burn_subtitles: z.boolean().optional().describe('Whether to burn subtitle_text into THIS variant. Default true.'),
+      include_audio: z.boolean().optional().describe('Whether to mux segment.audio_path into THIS variant. Default true. '
+        + 'Pass false for a fully silent copy (skips audio mux entirely; segment.audio_path is ignored for this variant).'),
+    })).optional().describe('Multi-output mode: one call produces all variants. '
+      + 'Visual segment processing (the heavy work) runs once; each variant only repeats audio mux + concat + optional subtitle burn. '
+      + 'Typical use: [{output_path:"with-sub.mp4"}, {output_path:"clean.mp4", burn_subtitles:false, include_audio:false}] '
+      + 'to deliver a subtitled+voiced version and a silent clean version together.'),
   },
   async (args) => {
     const segments = Array.isArray(args?.segments) ? args.segments : [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/_vendor/video/composer-v2/index.js

@@ -249,17 +249,64 @@ async function applyFadeTransition({ clipA, clipB, tmpDir, style = 'fade' }) {
   return outPath;
 }
 
+// compose_video_v2 supports two modes:
+//
+//   1. Legacy single-output: pass output_path (+ optional burn_subtitles).
+//      Returns { path, duration_ms, size_bytes, variants: [..1 entry..] }.
+//
+//   2. Multi-variant: pass variants=[{output_path, burn_subtitles?, include_audio?}, ...].
+//      Visual segment processing runs ONCE (the heavy part — per-segment ffmpeg
+//      transcode/scale/scroll). Each variant then diverges only at audio mux +
+//      concat + subtitle burn — typically a few seconds per extra variant.
+//      Returns { variants: [{path, duration_ms, size_bytes, burn_subtitles,
+//      include_audio}, ...] }.
+//
+// Use the multi-variant mode when shipping the same content with different
+// subtitle/audio combinations (e.g. subtitled+voiced + clean silent). Calling
+// the legacy mode twice produces correct outputs but redoes per-segment work.
 export async function composeVideoV2({
   segments = [],
   outro_paths = [],
   resolution = '1080x1920',
   output_path,
   burn_subtitles = true,
+  variants,
 }) {
   if (!Array.isArray(segments) || segments.length === 0) {
     throw new Error('segments must be a non-empty array');
   }
 
+  // Normalize variants. If caller did not pass an explicit variants array,
+  // synthesize a single variant from the legacy output_path + burn_subtitles.
+  // include_audio defaults to true (auto-include any segment.audio_path).
+  const normalizedVariants = (Array.isArray(variants) && variants.length > 0)
+    ? variants.map((v, idx) => {
+        if (!v || typeof v !== 'object') {
+          throw new Error(`variants[${idx}]: must be an object`);
+        }
+        const outPath = String(v.output_path ?? '').trim();
+        if (!outPath) throw new Error(`variants[${idx}]: output_path is required`);
+        return {
+          output_path: outPath,
+          burn_subtitles: v.burn_subtitles !== false,
+          include_audio: v.include_audio !== false,
+        };
+      })
+    : [{
+        output_path: output_path ?? path.join(os.tmpdir(), `lightcone-video-${Date.now()}.mp4`),
+        burn_subtitles: burn_subtitles !== false,
+        include_audio: true,
+      }];
+
+  // Disallow two variants writing to the same file — would race on disk.
+  const seenOutputs = new Set();
+  for (const v of normalizedVariants) {
+    if (seenOutputs.has(v.output_path)) {
+      throw new Error(`variants share output_path "${v.output_path}" — each variant needs a unique destination`);
+    }
+    seenOutputs.add(v.output_path);
+  }
+
   const [widthStr, heightStr] = String(resolution).split('x');
   const width = parseInt(widthStr, 10) || DEFAULT_WIDTH;
   const height = parseInt(heightStr, 10) || DEFAULT_HEIGHT;
@@ -268,23 +315,19 @@ export async function composeVideoV2({
   const tmpDir = path.join(os.tmpdir(), `compose-v2-${randomUUID().slice(0, 8)}`);
   await mkdir(tmpDir, { recursive: true });
 
-  const outPath = output_path ?? path.join(os.tmpdir(), `lightcone-video-${Date.now()}.mp4`);
-  await mkdir(path.dirname(outPath), { recursive: true });
-
   try {
-    const readyClips = [];
-
+    // ── Shared phase: generate visual clips per segment ONCE ──────────────────
+    // This is the heavy work (image scaling, scroll rendering, video resize +
+    // re-encode). Reused across every variant.
+    const visualClips = [];
     for (let i = 0; i < segments.length; i++) {
       const seg = segments[i];
       const kind = String(seg.visual_kind ?? 'image');
       const presentation = seg.presentation ?? {};
       const style = String(presentation.style ?? 'static');
       const duration = Number(presentation.duration ?? presentation.per_card_duration ?? 4);
-      const audioPath = seg.audio_path ?? null;
-      const transition = String(seg.transition ?? 'cut');
 
       let visualClip;
-
       if (kind === 'image') {
         const imgPath = String(seg.visual_path ?? '');
         if (!imgPath) throw new Error(`segments[${i}]: visual_path required for kind=image`);
@@ -312,119 +355,145 @@ export async function composeVideoV2({
       } else {
         throw new Error(`segments[${i}]: unknown visual_kind "${kind}"`);
       }
-
-      let finalClip;
-      if (audioPath && await fileExists(audioPath)) {
-        finalClip = await muxAudio({ videoPath: visualClip.path, audioPath, duration: visualClip.duration, tmpDir });
-      } else {
-        finalClip = await silentClip({ videoPath: visualClip.path, duration: visualClip.duration, tmpDir });
-      }
-
-      // Accept `text` as an alias for `subtitle_text`: plan_video_segments takes
-      // segment narration as `text` on input, compose_video_v2's canonical name is
-      // `subtitle_text`. Either reaches the burn pass so subtitles aren't silently dropped.
-      // burn_subtitles=false (dual-version delivery: same segments composed once
-      // with subtitles and once without) drops the text here so the burn-in pass
-      // skips entirely — saves the second compose having to mutate the segment array.
-      const subtitleText = burn_subtitles
-        ? (
-            typeof seg.subtitle_text === 'string' ? seg.subtitle_text
-            : typeof seg.text === 'string' ? seg.text
-            : ''
-          ).trim()
-        : '';
-      readyClips.push({ path: finalClip, duration: visualClip.duration, transition, subtitleText });
+      visualClips.push(visualClip);
     }
 
-    const outroClips = [];
+    // Outros are also shared — they don't depend on subtitle/audio choices.
+    const outroClipPaths = [];
     for (const outroPath of (outro_paths ?? [])) {
       if (outroPath && await fileExists(outroPath)) {
         const c = await videoToClip({ videoPath: outroPath, tmpDir, width, height, fps });
-        outroClips.push(c.path);
+        outroClipPaths.push(c.path);
       }
     }
 
-    // Build subtitle entries with cumulative timeline timestamps. When a clip's
-    // subtitle text spans several sentences, split it into one event per sentence
-    // and spread them across the clip in proportion to their length, so a long
-    // beat reads as sequential lines roughly tracking the narration instead of one
-    // static wall of text.
-    let cursorMs = 0;
-    const subtitleEntries = [];
-    for (const clip of readyClips) {
-      if (clip.subtitleText) {
-        const clipMs = Math.round(clip.duration * 1000);
-        const sentences = splitSubtitleSentences(clip.subtitleText);
-        const totalLen = sentences.reduce((sum, s) => sum + Array.from(s).length, 0) || 1;
-        let offsetMs = 0;
-        sentences.forEach((sentence, idx) => {
-          const share = Array.from(sentence).length / totalLen;
-          const isLast = idx === sentences.length - 1;
-          const spanMs = isLast ? clipMs - offsetMs : Math.max(1, Math.round(clipMs * share));
-          subtitleEntries.push({
-            text: sentence,
-            start_ms: cursorMs + offsetMs,
-            end_ms: cursorMs + offsetMs + spanMs,
+    // ── Per-variant phase ─────────────────────────────────────────────────────
+    // For each variant: mux audio (or silent), build subtitle text, concat with
+    // transitions, optionally burn subtitles. Writes to variant.output_path.
+    const variantOutputs = [];
+    for (let vi = 0; vi < normalizedVariants.length; vi++) {
+      const variant = normalizedVariants[vi];
+      await mkdir(path.dirname(variant.output_path), { recursive: true });
+
+      const variantTag = `v${vi}`;
+      const readyClips = [];
+
+      for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const visualClip = visualClips[i];
+        const transition = String(seg.transition ?? 'cut');
+        const audioPath = variant.include_audio ? (seg.audio_path ?? null) : null;
+
+        let finalClip;
+        if (audioPath && await fileExists(audioPath)) {
+          finalClip = await muxAudio({ videoPath: visualClip.path, audioPath, duration: visualClip.duration, tmpDir });
+        } else {
+          finalClip = await silentClip({ videoPath: visualClip.path, duration: visualClip.duration, tmpDir });
+        }
+
+        // Accept `text` as an alias for `subtitle_text`: plan_video_segments takes
+        // segment narration as `text` on input, compose_video_v2's canonical name is
+        // `subtitle_text`. burn_subtitles=false drops the text here so the burn-in
+        // pass skips entirely.
+        const subtitleText = variant.burn_subtitles
+          ? (
+              typeof seg.subtitle_text === 'string' ? seg.subtitle_text
+              : typeof seg.text === 'string' ? seg.text
+              : ''
+            ).trim()
+          : '';
+        readyClips.push({ path: finalClip, duration: visualClip.duration, transition, subtitleText });
+      }
+
+      // Subtitle entries: cumulative timeline timestamps. Same logic as before,
+      // scoped per variant (subtitleText is already gated by variant.burn_subtitles).
+      let cursorMs = 0;
+      const subtitleEntries = [];
+      for (const clip of readyClips) {
+        if (clip.subtitleText) {
+          const clipMs = Math.round(clip.duration * 1000);
+          const sentences = splitSubtitleSentences(clip.subtitleText);
+          const totalLen = sentences.reduce((sum, s) => sum + Array.from(s).length, 0) || 1;
+          let offsetMs = 0;
+          sentences.forEach((sentence, idx) => {
+            const share = Array.from(sentence).length / totalLen;
+            const isLast = idx === sentences.length - 1;
+            const spanMs = isLast ? clipMs - offsetMs : Math.max(1, Math.round(clipMs * share));
+            subtitleEntries.push({
+              text: sentence,
+              start_ms: cursorMs + offsetMs,
+              end_ms: cursorMs + offsetMs + spanMs,
+            });
+            offsetMs += spanMs;
           });
-          offsetMs += spanMs;
-        });
+        }
+        cursorMs += Math.round(clip.duration * 1000);
       }
-      cursorMs += Math.round(clip.duration * 1000);
-    }
 
-    const allClips = [];
-    let accumulated = readyClips[0].path;
-    for (let i = 1; i < readyClips.length; i++) {
-      const { path: nextClip, transition } = readyClips[i];
-      if (transition === 'fade' || transition === 'crossfade') {
-        accumulated = await applyFadeTransition({ clipA: accumulated, clipB: nextClip, tmpDir, style: transition });
-      } else {
-        allClips.push(accumulated);
-        accumulated = nextClip;
+      const allClips = [];
+      let accumulated = readyClips[0].path;
+      for (let i = 1; i < readyClips.length; i++) {
+        const { path: nextClip, transition } = readyClips[i];
+        if (transition === 'fade' || transition === 'crossfade') {
+          accumulated = await applyFadeTransition({ clipA: accumulated, clipB: nextClip, tmpDir, style: transition });
+        } else {
+          allClips.push(accumulated);
+          accumulated = nextClip;
+        }
       }
-    }
-    allClips.push(accumulated);
+      allClips.push(accumulated);
 
-    const finalSequence = [...allClips, ...outroClips];
+      const finalSequence = [...allClips, ...outroClipPaths];
 
-    // Compose without subtitles first (subtitles are burned in a separate pass)
-    const preSubPath = subtitleEntries.length > 0
-      ? path.join(tmpDir, `pre-sub-${randomUUID().slice(0, 8)}.mp4`)
-      : outPath;
+      // Compose without subtitles first (subtitles are burned in a separate pass)
+      const preSubPath = subtitleEntries.length > 0
+        ? path.join(tmpDir, `${variantTag}-pre-sub-${randomUUID().slice(0, 8)}.mp4`)
+        : variant.output_path;
 
-    if (finalSequence.length === 1) {
-      await runFfmpeg(['-i', finalSequence[0], '-c', 'copy', '-movflags', '+faststart', preSubPath], 'ffmpeg copy');
-    } else {
-      await concatWithCuts({ clips: finalSequence, outputPath: preSubPath });
-    }
+      if (finalSequence.length === 1) {
+        await runFfmpeg(['-i', finalSequence[0], '-c', 'copy', '-movflags', '+faststart', preSubPath], `ffmpeg copy ${variantTag}`);
+      } else {
+        await concatWithCuts({ clips: finalSequence, outputPath: preSubPath });
+      }
 
-    // Burn subtitles into final output
-    if (subtitleEntries.length > 0) {
-      const assPath = path.join(tmpDir, `subs-${randomUUID().slice(0, 8)}.ass`);
-      await writeFile(assPath, buildAssContent(subtitleEntries, { playResX: width, playResY: height }));
-      const escapedAssPath = assPath.replace(/\\/g, '/').replace(/:/g, '\\:').replace(/'/g, "\\'");
-      await runFfmpeg([
-        '-i', preSubPath,
-        '-vf', `subtitles='${escapedAssPath}'`,
-        '-c:a', 'copy',
-        '-movflags', '+faststart',
-        outPath,
-      ], 'ffmpeg burn-subtitles');
-    }
+      if (subtitleEntries.length > 0) {
+        const assPath = path.join(tmpDir, `${variantTag}-subs-${randomUUID().slice(0, 8)}.ass`);
+        await writeFile(assPath, buildAssContent(subtitleEntries, { playResX: width, playResY: height }));
+        const escapedAssPath = assPath.replace(/\\/g, '/').replace(/:/g, '\\:').replace(/'/g, "\\'");
+        await runFfmpeg([
+          '-i', preSubPath,
+          '-vf', `subtitles='${escapedAssPath}'`,
+          '-c:a', 'copy',
+          '-movflags', '+faststart',
+          variant.output_path,
+        ], `ffmpeg burn-subtitles ${variantTag}`);
+      }
 
-    const totalDuration = await probeDurationSec(outPath);
-
-    // Stat the final file before returning so the caller can rely on size and
-    // so we can detect the (rare but observed) case where ffmpeg's `close`
-    // arrived but the kernel writeback wasn't complete. A 0-byte / tiny mp4
-    // here means the burn-subtitles pass produced nothing usable — fail loudly
-    // instead of letting a broken file flow into write_workspace_file / submit.
-    const finalStat = await statAsync(outPath);
-    const sizeBytes = Number(finalStat.size ?? 0);
-    if (!Number.isFinite(sizeBytes) || sizeBytes < 1024) {
-      throw new Error(`compose_video_v2 produced an invalid output: ${outPath} size=${sizeBytes} bytes`);
+      const totalDuration = await probeDurationSec(variant.output_path);
+      const finalStat = await statAsync(variant.output_path);
+      const sizeBytes = Number(finalStat.size ?? 0);
+      if (!Number.isFinite(sizeBytes) || sizeBytes < 1024) {
+        throw new Error(`compose_video_v2 produced an invalid output: ${variant.output_path} size=${sizeBytes} bytes (variant ${vi})`);
+      }
+
+      variantOutputs.push({
+        path: variant.output_path,
+        duration_ms: Math.round(totalDuration * 1000),
+        size_bytes: sizeBytes,
+        burn_subtitles: variant.burn_subtitles,
+        include_audio: variant.include_audio,
+      });
     }
-    return { path: outPath, duration_ms: Math.round(totalDuration * 1000), size_bytes: sizeBytes };
+
+    // Legacy single-output callers (didn't pass variants) get the same flat
+    // shape they used to get, plus the variants array for forward-compat.
+    const first = variantOutputs[0];
+    return {
+      path: first.path,
+      duration_ms: first.duration_ms,
+      size_bytes: first.size_bytes,
+      variants: variantOutputs,
+    };
   } finally {
     await rm(tmpDir, { recursive: true, force: true });
   }

package/src/tools/compose-video-v2.js

@@ -22,8 +22,16 @@ function statSizeOrNull(p) {
   try { return fs.statSync(p).size; } catch { return null; }
 }
 
-export async function runComposeVideoV2Tool({ segments, outro_paths, format, resolution, output_path, burn_subtitles, workspaceDir }) {
-  const burnSubtitles = burn_subtitles !== false;
+export async function runComposeVideoV2Tool({
+  segments,
+  outro_paths,
+  format,
+  resolution,
+  output_path,
+  burn_subtitles,
+  variants,
+  workspaceDir,
+}) {
   if (!Array.isArray(segments) || segments.length === 0) {
     return toolError('segments must be a non-empty array.');
   }
@@ -60,6 +68,37 @@ export async function runComposeVideoV2Tool({ segments, outro_paths, format, res
       );
     }
   }
+
+  // Normalize variants. If caller passed a variants[] array, that takes
+  // priority — multi-output mode. Otherwise build a single-element variants
+  // array from the legacy output_path + burn_subtitles params.
+  const outDir = workspaceDir
+    ? path.join(workspaceDir, 'artifacts', 'video')
+    : path.join(os.tmpdir(), 'lightcone-video');
+
+  let normalizedVariants;
+  if (Array.isArray(variants) && variants.length > 0) {
+    normalizedVariants = variants.map((v, idx) => {
+      if (!v || typeof v !== 'object') {
+        return null; // surfaced below
+      }
+      const outPath = String(v.output_path ?? '').trim()
+        || path.join(outDir, `composed-${Date.now()}-${idx}-${randomUUID().slice(0, 8)}.mp4`);
+      return {
+        output_path: outPath,
+        burn_subtitles: v.burn_subtitles !== false,
+        include_audio: v.include_audio !== false,
+      };
+    });
+    if (normalizedVariants.some(v => v === null)) {
+      return toolError('variants must be an array of objects, each with { output_path, burn_subtitles?, include_audio? }.');
+    }
+  } else {
+    const burnSubtitles = burn_subtitles !== false;
+    const outPath = output_path ?? path.join(outDir, `composed-${Date.now()}-${randomUUID().slice(0, 8)}.mp4`);
+    normalizedVariants = [{ output_path: outPath, burn_subtitles: burnSubtitles, include_audio: true }];
+  }
+
   const warnings = [];
   // Heuristic warning: a multi-segment image video that reuses one single image
   // will look near-static — usually a sign the source page didn't render and the
@@ -70,48 +109,59 @@ export async function runComposeVideoV2Tool({ segments, outro_paths, format, res
       + 'The output will be near-static — verify the source page actually rendered before submitting this video.'
     );
   }
-  // Warn when narration is present but no subtitle text is — compose_video_v2 burns
-  // subtitles only from `subtitle_text` (or its `text` alias); without it the video
-  // ships with no captions. Simplest fix: pass plan_video_segments' output verbatim.
-  // burn_subtitles=false is the explicit "no subtitles" path (dual-version delivery),
-  // so the warning would be noise — suppress it.
-  if (burnSubtitles) {
+  // Warn when narration is present but no subtitle text is — only meaningful
+  // for variants that ARE supposed to burn subtitles. Variants that explicitly
+  // ask for burn_subtitles=false are the "clean" path and shouldn't trigger it.
+  const variantsWithBurn = normalizedVariants.filter(v => v.burn_subtitles && v.include_audio);
+  if (variantsWithBurn.length > 0) {
     const hasSubText = s => (typeof s?.subtitle_text === 'string' && s.subtitle_text.trim())
       || (typeof s?.text === 'string' && s.text.trim());
     const narratedNoSub = segments.filter(s =>
       (typeof s?.audio_path === 'string' && s.audio_path.trim()) && !hasSubText(s)).length;
     if (narratedNoSub > 0) {
       warnings.push(
-        `WARNING: ${narratedNoSub} segment(s) have narration audio but no subtitle text — the output will have NO subtitles. `
+        `WARNING: ${narratedNoSub} segment(s) have narration audio but no subtitle text — `
+        + `the subtitled variant${variantsWithBurn.length > 1 ? 's' : ''} will have NO subtitles. `
         + 'If subtitles are wanted, set subtitle_text per segment (or pass the plan_video_segments output array verbatim).'
       );
     }
   }
 
-  const outDir = workspaceDir
-    ? path.join(workspaceDir, 'artifacts', 'video')
-    : path.join(os.tmpdir(), 'lightcone-video');
-
-  const outPath = output_path ?? path.join(outDir, `composed-${Date.now()}-${randomUUID().slice(0, 8)}.mp4`);
-
   try {
     const result = await composeVideoV2({
       segments,
       outro_paths: outro_paths ?? [],
       resolution: resolution ?? '1080x1920',
-      output_path: outPath,
-      burn_subtitles: burnSubtitles,
+      variants: normalizedVariants,
     });
 
-    const lines = [
-      'compose_video_v2 completed.',
-      `path=${result.path}`,
-      `duration_ms=${result.duration_ms}`,
-      `size_bytes=${result.size_bytes ?? 'unknown'}`,
-      `segments=${segments.length}`,
-      `outro_clips=${(outro_paths ?? []).length}`,
-      `burn_subtitles=${burnSubtitles}`,
-    ];
+    const outputs = Array.isArray(result?.variants) && result.variants.length > 0
+      ? result.variants
+      : [{ path: result.path, duration_ms: result.duration_ms, size_bytes: result.size_bytes,
+           burn_subtitles: normalizedVariants[0].burn_subtitles,
+           include_audio: normalizedVariants[0].include_audio }];
+
+    const lines = ['compose_video_v2 completed.'];
+    if (outputs.length === 1) {
+      const v = outputs[0];
+      lines.push(`path=${v.path}`);
+      lines.push(`duration_ms=${v.duration_ms}`);
+      lines.push(`size_bytes=${v.size_bytes ?? 'unknown'}`);
+      lines.push(`burn_subtitles=${v.burn_subtitles}`);
+      lines.push(`include_audio=${v.include_audio}`);
+    } else {
+      lines.push(`variants=${outputs.length}`);
+      outputs.forEach((v, idx) => {
+        lines.push(`--- variant ${idx} ---`);
+        lines.push(`path=${v.path}`);
+        lines.push(`duration_ms=${v.duration_ms}`);
+        lines.push(`size_bytes=${v.size_bytes ?? 'unknown'}`);
+        lines.push(`burn_subtitles=${v.burn_subtitles}`);
+        lines.push(`include_audio=${v.include_audio}`);
+      });
+    }
+    lines.push(`segments=${segments.length}`);
+    lines.push(`outro_clips=${(outro_paths ?? []).length}`);
     for (const w of warnings) lines.push(w);
     return toolText(lines.join('\n'));
   } catch (error) {