@amg555/frameforge-mcp 2.7.3 → 2.7.7

package/src/mcp-server/server.js

@@ -1,7 +1,7 @@
 /**
  * FrameForge MCP Server — MCP 2024-11-05 spec compliant
  *
- * Exposes 28 video production & autonomous editing tools via MCP.
+ * Exposes 34 video production & autonomous editing tools via MCP.
  * Works with IBM Bob, Cursor, Windsurf, Codex, opencode, Claude Code, or any MCP-capable IDE.
  * Primary connection: Cloudflare Remote MCP (cloudflare-mcp/).
  * Alternative: stdio (src/mcp-server/stdio.js) or HTTP (this file).
@@ -356,9 +356,10 @@ const TOOLS = {
         title:        { type: 'string',  description: 'Video title' },
         language:     { type: 'string',  description: 'BCP-47 language hint (e.g. ml, hi, en, ta)' },
         showCaptions: { type: 'boolean', default: false, description: 'Display on-screen synchronized subtitles/captions. Default false.' },
+        showAnchor:   { type: 'boolean', default: false, description: 'Display on-screen anchor/presenter character. Default false.' },
       },
     },
-    handler: async ({ productionId, scenes, orientation = 'landscape', skipImages = false, skipTts = false, withMusic = true, musicVolume = 0.07, topic = '', style = '', theme = '', title = '', language = '', showCaptions = false }) => {
+    handler: async ({ productionId, scenes, orientation = 'landscape', skipImages = false, skipTts = false, withMusic = true, musicVolume = 0.07, topic = '', style = '', theme = '', title = '', language = '', showCaptions = false, showAnchor = false }) => {
       const syncFs = require('fs');
       const { runAssets }   = require('../workflows/assets');
       const { runRender }   = require('../workflows/render');
@@ -404,6 +405,8 @@ const TOOLS = {
         theme,
         title,
         language,
+        showCaptions,
+        showAnchor,
         imageWidth:  renderWidth,
         imageHeight: renderHeight,
       });
@@ -422,6 +425,7 @@ const TOOLS = {
         title,
         language,
         showCaptions,
+        showAnchor,
       });
 
       if (!renderResult.passed) {
@@ -580,7 +584,7 @@ Example scene:
         voice:          { type: 'string',  description: 'edge-tts voice ID for all scenes, e.g. "ml-IN-MidhunNeural" (Malayalam male), "en-US-BrianNeural" (English). Per-scene voice field overrides this. Full list: edge-tts --list-voices' },
         language:       { type: 'string',  description: 'BCP-47 language hint, e.g. "ml" (Malayalam), "hi" (Hindi), "ta" (Tamil), "te" (Telugu), "en" (English). Auto-selects a default voice for the language when voice is not set.' },
         skipTts:        { type: 'boolean', default: false, description: 'Set true if all scenes already have audio_path' },
-        parallelism:    { type: 'number',  default: 1, description: 'Concurrent TTS synthesis requests (default: 1).' },
+        parallelism:    { type: 'number',  default: 4, description: 'Concurrent TTS synthesis requests (default: 4 for fast multi-scene production).' },
         withMusic:      { type: 'boolean', default: true },
         musicVolume:    { type: 'number',  default: 0.07 },
         topic:          { type: 'string',  description: 'Overall topic/genre for visual aesthetic and background motion (e.g. "Kerala history", "crypto finance", "AI robotics")' },
@@ -591,7 +595,7 @@ Example scene:
         productionId:   { type: 'string',  description: 'Optional — reuse an existing productionId' },
       },
     },
-    handler: async ({ scenes, title = 'FrameForge Video', orientation = 'landscape', voice, language, skipTts = false, parallelism = 1, withMusic = true, musicVolume = 0.07, topic = '', style = '', theme = '', showCaptions = false, showAnchor = false, productionId }) => {
+    handler: async ({ scenes, title = 'FrameForge Video', orientation = 'landscape', voice, language, skipTts = false, parallelism = 4, withMusic = true, musicVolume = 0.07, topic = '', style = '', theme = '', showCaptions = false, showAnchor = false, productionId }) => {
       const { runAssets } = require('../workflows/assets');
       const { runRender } = require('../workflows/render');
 
@@ -2120,7 +2124,7 @@ Professional audio rules applied:
       planMd += `- L-cuts: current audio extends 0.3s into next clip's video\n\n`;
       planMd += `## 🚀 Execution & Approval\n\n`;
       planMd += `Review this plan, then execute with \`edit_video\` using the payload in \`edit.json\`.\n`;
-      planMd += `\nGenerated by FrameForge v2.7.3 — plan_video_edit with J/L-cut support (lemo-opuscar DIRECTOR.md)\n`;
+      planMd += `\nGenerated by FrameForge v2.7.7 — plan_video_edit with J/L-cut support (lemo-opuscar DIRECTOR.md)\n`;
 
       // 8. Build TREATMENT.md (lemo-opuscar DIRECTOR.md — 8-section format)
       let treatmentMd = '';
@@ -2161,7 +2165,7 @@ Professional audio rules applied:
         treatmentMd += `## 8. Director Notes\n\n`;
         treatmentMd += `_Add creative direction, mood references, or client notes here._\n\n`;
         treatmentMd += `---\n\n`;
-        treatmentMd += `*Generated by FrameForge v2.7.3 — lemo-opuscar DIRECTOR.md format*\n`;
+        treatmentMd += `*Generated by FrameForge v2.7.7 — lemo-opuscar DIRECTOR.md format*\n`;
       }
 
       // 9. Write outputs
@@ -2237,12 +2241,12 @@ Professional audio rules applied:
   // ── Tool 28: Check Upstream Updates (fast, offline) ───────────────────────
   // Reads last sync manifest without network requests — returns update status instantly
   check_upstream_updates: {
-    description: `Check the last sync state of all upstream reference repositories (HyperFrames, OneTake, LemoOpuscar, CollageBroll, Remotion, Earshot, ClaudeAnimationBase, ClaudeRemotionSkill, FFmpegSkill). Fast, offline — reads the local manifest only (no network requests). Shows what was last synced, when, which repos had updates, and a human-readable changelog of what improved. To actually fetch new commits and update the manifest, use sync_upstream_skills. Agents and users can call this anytime to see if upstream skills have been updated since the last sync.`,
+    description: `Check the last sync state of all upstream reference repositories (HyperFrames, OneTake, LemoOpuscar, CollageBroll, Remotion, Earshot, ClaudeAnimationBase, ClaudeRemotionSkill, FFmpegSkill, AiinsightShorts). Fast, offline — reads the local manifest only (no network requests). Shows what was last synced, when, which repos had updates, and a human-readable changelog of what improved. To actually fetch new commits and update the manifest, use sync_upstream_skills. Agents and users can call this anytime to see if upstream skills have been updated since the last sync.`,
     inputSchema: { type: 'object', properties: {} },
     handler: async () => {
       const syncFs = require('fs');
       const { MANIFEST_PATH, REPOSITORIES } = require('../skills/sync-upstream');
-      let manifest = { lastSync: null, repos: {}, version: '2.7.3', pendingUpdates: [] };
+      let manifest = { lastSync: null, repos: {}, version: '2.7.7', pendingUpdates: [] };
       if (syncFs.existsSync(MANIFEST_PATH)) {
         try { manifest = JSON.parse(syncFs.readFileSync(MANIFEST_PATH, 'utf8')); } catch (_) {}
       }
@@ -2289,7 +2293,7 @@ Professional audio rules applied:
       return {
         success: true,
         lastSync: manifest.lastSync,
-        manifestVersion: manifest.version || '2.7.3',
+        manifestVersion: manifest.version || '2.7.7',
         totalRepos: repos.length,
         syncedCount,
         pendingUpdates,
@@ -2814,13 +2818,725 @@ Outputs broadcast-ready 48kHz/192k AAC stereo.`,
     },
   },
 
+  // ── Tool 29: List Faceless Short Styles ─────────────────────────────────
+  // Returns the 6 aiinsight-shorts styles with descriptions, palettes, and use-cases.
+  list_short_styles: {
+    description: 'List all available faceless-shorts styles from the aiinsight-shorts library. Returns name, description, look rules, typical length, and when to use each style. Six styles: Deep Dive 3D (Zack D. Films-like body/science explainer), Night File 3D (true crime/mysteries), Inside Out (flat 2D x-ray explainer), Stick Story (stick-figure survival steps), Paper Atlas (history in cut paper), Tall Tale 3D (funny true stories).',
+    inputSchema: { type: 'object', properties: {} },
+    handler: async () => {
+      const syncFs = require('fs');
+      const pathMod = require('path');
+      const SHORTS_DIR = pathMod.resolve(__dirname, '../../plugins/aiinsight-shorts/styles');
+      const STYLES = [
+        { id: 'deep-dive',    label: 'Deep Dive 3D',  when: 'body / health / science "what happens if" → flagship 3D', length: '30-45 s', dim: '1080×1920 · 24 fps', voice: 'am_michael', music: 'tension' },
+        { id: 'night-file',   label: 'Night File 3D', when: 'creepy / unexplained / true crime / "this happened in 1971"', length: '30-45 s', dim: '1080×1920 · 24 fps', voice: 'am_onyx', music: 'tension' },
+        { id: 'inside-out',   label: 'Inside Out',    when: 'flat 2D "what happens if" explainer — lighter and faster', length: '25-40 s', dim: '1080×1920 · 30 fps', voice: 'am_michael', music: 'bed' },
+        { id: 'stick-story',  label: 'Stick Story',   when: 'survival / life hacks / "here\'s what you do"', length: '30-45 s', dim: '1080×1920 · 30 fps', voice: 'am_puck', music: 'bed' },
+        { id: 'paper-atlas',  label: 'Paper Atlas',   when: 'historical event / "how X happened"', length: '30-45 s', dim: '1080×1920 · 30 fps', voice: 'bm_george', music: 'tension' },
+        { id: 'tall-tale',    label: 'Tall Tale 3D',  when: 'funny / clever true story / con / loophole / "this guy did X"', length: '40-60 s', dim: '1080×1920 · 30 fps', voice: 'am_michael', music: 'bounce' },
+      ];
+
+      const result = [];
+      for (const s of STYLES) {
+        const styleMdPath = pathMod.join(SHORTS_DIR, s.id, 'STYLE.md');
+        let rules = '';
+        try { rules = syncFs.readFileSync(styleMdPath, 'utf8'); } catch (_) {}
+        const sheetPath = pathMod.join(SHORTS_DIR, s.id, 'style-sheet.png');
+        result.push({
+          ...s,
+          styleGuide: styleMdPath,
+          styleSheetPng: syncFs.existsSync(sheetPath) ? sheetPath : null,
+          exampleDir: pathMod.join(SHORTS_DIR, s.id, 'example'),
+          styleMarkdown: rules,
+        });
+      }
+
+      return {
+        styles: result,
+        count: result.length,
+        skillDir: pathMod.resolve(__dirname, '../../plugins/aiinsight-shorts'),
+        newVideoScript: pathMod.resolve(__dirname, '../../plugins/aiinsight-shorts/scripts/new_video.sh'),
+        voiceScript: pathMod.resolve(__dirname, '../../plugins/aiinsight-shorts/scripts/voice.py'),
+        wordsScript: pathMod.resolve(__dirname, '../../plugins/aiinsight-shorts/scripts/words.py'),
+        estimateScript: pathMod.resolve(__dirname, '../../plugins/aiinsight-shorts/scripts/estimate.py'),
+        message: `${result.length} faceless-short styles available. Call create_short to scaffold a new project from any style.`,
+      };
+    },
+  },
+
+  // ── Tool 30: Create Faceless Short Project ──────────────────────────────
+  // Scaffolds a new short video project from one of the 6 aiinsight-shorts styles.
+  create_short: {
+    description: `Scaffold a new faceless YouTube Short / TikTok / Reel project from the aiinsight-shorts library.
+Copies the chosen style's full working example (engine, shots, fonts, tools) into a project folder, removes the example narration audio so it renders fresh, and prints the next steps.
+
+Six styles: deep-dive (3D body/science "what happens if"), night-file (3D true crime/mystery), inside-out (flat 2D x-ray explainer), stick-story (stick-figure survival), paper-atlas (history in cut paper), tall-tale (3D funny true story).
+
+After scaffolding: edit script.json (narration lines + caption chunks), run voice.py → words.py to generate TTS + word timing, rewrite src/shots.js for your content, then node tools/capture.mjs video to render the MP4.`,
+    inputSchema: {
+      type: 'object',
+      required: ['style', 'shortName'],
+      properties: {
+        style:     { type: 'string', enum: ['deep-dive', 'night-file', 'inside-out', 'stick-story', 'paper-atlas', 'tall-tale'], description: 'Style to use' },
+        shortName: { type: 'string', description: 'URL-safe project name, e.g. "what-if-you-swallow-gum"' },
+        outputDir: { type: 'string', description: 'Parent directory for the project. Defaults to ~/faceless-shorts/<shortName>/' },
+      },
+    },
+    handler: async ({ style, shortName, outputDir }) => {
+      const syncFs = require('fs');
+      const pathMod = require('path');
+      const { spawnSync } = require('child_process');
+
+      const VALID_STYLES = ['deep-dive', 'night-file', 'inside-out', 'stick-story', 'paper-atlas', 'tall-tale'];
+      if (!VALID_STYLES.includes(style)) {
+        throw new Error(`Unknown style "${style}". Choose one of: ${VALID_STYLES.join(', ')}`);
+      }
+      if (!shortName || !/^[a-z0-9-_]+$/i.test(shortName)) {
+        throw new Error('shortName must be URL-safe (letters, digits, hyphens, underscores only)');
+      }
+
+      const skillDir = pathMod.resolve(__dirname, '../../plugins/aiinsight-shorts');
+      const srcExample = pathMod.join(skillDir, 'styles', style, 'example');
+      if (!syncFs.existsSync(srcExample)) {
+        throw new Error(`Style example not found at: ${srcExample}`);
+      }
+
+      const parent = outputDir
+        ? pathMod.resolve(outputDir)
+        : pathMod.join(require('os').homedir(), 'faceless-shorts');
+      const dst = pathMod.join(parent, shortName);
+
+      if (syncFs.existsSync(dst)) {
+        throw new Error(`Project already exists: ${dst}. Choose a different shortName or remove it first.`);
+      }
+
+      // Copy example recursively
+      const copyDir = (src, dest) => {
+        syncFs.mkdirSync(dest, { recursive: true });
+        for (const entry of syncFs.readdirSync(src, { withFileTypes: true })) {
+          const s = pathMod.join(src, entry.name);
+          const d = pathMod.join(dest, entry.name);
+          if (entry.isDirectory()) { copyDir(s, d); }
+          else { syncFs.copyFileSync(s, d); }
+        }
+      };
+      copyDir(srcExample, dst);
+
+      // Create renders/ and review/ dirs (new_video.sh does this too)
+      syncFs.mkdirSync(pathMod.join(dst, 'renders'), { recursive: true });
+      syncFs.mkdirSync(pathMod.join(dst, 'review'),  { recursive: true });
+
+      // Remove example audio so it renders fresh
+      for (const f of ['data/narration.wav', 'data/mix.wav']) {
+        const p = pathMod.join(dst, f);
+        try { syncFs.unlinkSync(p); } catch (_) {}
+      }
+
+      const styleMdPath = pathMod.join(skillDir, 'styles', style, 'STYLE.md');
+      const styleMd = syncFs.existsSync(styleMdPath) ? syncFs.readFileSync(styleMdPath, 'utf8') : '';
+
+      return {
+        success: true,
+        style,
+        shortName,
+        projectDir: dst,
+        scriptJson: pathMod.join(dst, 'script.json'),
+        shotsJs:    pathMod.join(dst, 'src', 'shots.js'),
+        captureCmd: `node ${pathMod.join(dst, 'tools', 'capture.mjs')} check`,
+        voiceCmd:   `python ${pathMod.join(skillDir, 'scripts', 'voice.py')} ${dst}`,
+        wordsCmd:   `python ${pathMod.join(skillDir, 'scripts', 'words.py')} ${dst}`,
+        renderCmd:  `node ${pathMod.join(dst, 'tools', 'capture.mjs')} video ${pathMod.join(dst, 'renders', shortName + '.mp4')}`,
+        styleGuide: styleMd,
+        message: [
+          `✅ Project scaffolded: ${dst}`,
+          ``,
+          `Next steps:`,
+          `1. Edit ${pathMod.join(dst, 'script.json')} — write your narration lines and caption chunks`,
+          `2. Run: python ${pathMod.join(skillDir, 'scripts', 'voice.py')} "${dst}"`,
+          `3. Run: python ${pathMod.join(skillDir, 'scripts', 'words.py')} "${dst}"`,
+          `4. Rewrite ${pathMod.join(dst, 'src', 'shots.js')} for your content (follow STYLE.md)`,
+          `5. Run: node ${pathMod.join(dst, 'tools', 'capture.mjs')} check  (must say CHECK OK)`,
+          `6. Run: node ${pathMod.join(dst, 'tools', 'capture.mjs')} cues`,
+          `7. Run: python ${pathMod.join(dst, 'tools', 'mix.py')} "${dst}"`,
+          `8. Run: node ${pathMod.join(dst, 'tools', 'capture.mjs')} video ${pathMod.join(dst, 'renders', shortName + '.mp4')}`,
+          ``,
+          `Style guide is included in this response (styleGuide field). Read it fully before writing shots.js.`,
+        ].join('\n'),
+      };
+    },
+  },
+
+  // ── Tool 31: Detect Viral Clips ──────────────────────────────────────────
+  // Transcribes a long video, scores transcript windows with an LLM, and
+  // returns ranked clip timestamps ready to pass to edit_video.
+  detect_viral_clips: {
+    description: `Analyze a long video (podcast, webinar, stream, interview) and detect the most viral-worthy moments. Returns ranked clip candidates with start/end timestamps, titles, and hook suggestions — ready to feed into edit_video or reframe.
+
+How it works:
+1. Transcribes the video with Whisper (local, free — same engine as transcribe_media).
+2. Splits the transcript into overlapping windows (default 45s, 10s overlap).
+3. Scores each window with an LLM (Gemini Flash via GEMINI_API_KEY, or any OpenAI-compatible endpoint via LLM_BASE_URL — including Ollama, LM Studio, vLLM).
+4. Returns the top N clip candidates sorted by viral score.
+
+No captions are added or burned into anything. This tool only detects moments and returns timestamps — use edit_video or karaoke_subtitles afterwards if you want subtitles on the clips.`,
+    inputSchema: {
+      type: 'object',
+      required: ['videoPath'],
+      properties: {
+        videoPath:       { type: 'string',  description: 'Path to the local video file to analyze (MP4, MOV, MKV, etc.)' },
+        targetClips:     { type: 'number',  default: 5,  description: 'Target number of clips to return (1-15, default 5). Actual count may be lower if the video lacks enough strong moments.' },
+        clipMinSeconds:  { type: 'number',  default: 15, description: 'Minimum clip length in seconds (default 15)' },
+        clipMaxSeconds:  { type: 'number',  default: 60, description: 'Maximum clip length in seconds (default 60)' },
+        windowSeconds:   { type: 'number',  default: 45, description: 'Transcript window size for scoring (default 45s)' },
+        language:        { type: 'string',  description: 'BCP-47 language hint for Whisper transcription (e.g. "en", "es"). Auto-detected if omitted.' },
+        whisperModel:    { type: 'string',  default: 'base', enum: ['tiny','base','small','medium'], description: 'Whisper model size (base = fast, small/medium = more accurate)' },
+        llmBaseUrl:      { type: 'string',  description: 'OpenAI-compatible LLM endpoint (e.g. http://localhost:11434/v1 for Ollama). Overrides GEMINI_API_KEY when set.' },
+        llmModel:        { type: 'string',  description: 'LLM model name for local endpoint (e.g. "llama3.1", "qwen2.5:7b"). Ignored when using Gemini.' },
+        geminiApiKey:    { type: 'string',  description: 'Google Gemini API key. Falls back to GEMINI_API_KEY env var.' },
+      },
+    },
+    handler: async ({
+      videoPath, targetClips = 5, clipMinSeconds = 15, clipMaxSeconds = 60,
+      windowSeconds = 45, language, whisperModel = 'base',
+      llmBaseUrl, llmModel, geminiApiKey,
+    }) => {
+      const syncFs   = require('fs');
+      const pathMod  = require('path');
+      const https    = require('https');
+      const http     = require('http');
+
+      if (!videoPath || !syncFs.existsSync(videoPath)) {
+        throw new Error(`videoPath does not exist: ${videoPath}`);
+      }
+      const clampedTarget = Math.max(1, Math.min(15, Math.round(targetClips)));
+
+      // ── Step 1: Transcribe ────────────────────────────────────────────────
+      const { transcribeAudio, detectWhisper } = require('../utils/transcribe');
+      const engine = detectWhisper();
+      if (!engine.available) {
+        throw new Error(
+          'Whisper is not installed. Install it with: pip install openai-whisper  (or: pip install faster-whisper)'
+        );
+      }
+
+      const transcriptResult = await transcribeAudio(videoPath, {
+        model: whisperModel,
+        language,
+        format: 'json',
+      });
+      if (!transcriptResult || !Array.isArray(transcriptResult.words) || transcriptResult.words.length === 0) {
+        throw new Error('Transcription returned no words. Check that the video has speech.');
+      }
+
+      const totalDuration = transcriptResult.duration || 0;
+      const words = transcriptResult.words; // [{ word, start, end }]
+
+      // ── Step 2: Build overlapping windows ────────────────────────────────
+      const overlap = Math.round(windowSeconds * 0.22); // ~22% overlap
+      const windows = [];
+      let winStart = 0;
+      while (winStart < totalDuration - clipMinSeconds) {
+        const winEnd = Math.min(winStart + windowSeconds, totalDuration);
+        const winWords = words.filter(w => w.start >= winStart && w.end <= winEnd + 1);
+        if (winWords.length >= 5) {
+          windows.push({
+            index: windows.length,
+            start: winStart,
+            end:   winEnd,
+            text:  winWords.map(w => w.word).join(' ').trim(),
+          });
+        }
+        winStart += windowSeconds - overlap;
+      }
+      if (windows.length === 0) {
+        return {
+          clips: [],
+          totalDuration,
+          message: 'No scoreable windows found — video may be too short or silent.',
+        };
+      }
+
+      // ── Step 3: Score windows with LLM ───────────────────────────────────
+      const resolvedGeminiKey = geminiApiKey || process.env.GEMINI_API_KEY;
+      const resolvedLlmUrl    = llmBaseUrl   || process.env.LLM_BASE_URL;
+
+      // Score in batches of 3 (safe for small context local LLMs) or 8 (Gemini)
+      const batchSize = resolvedLlmUrl ? 3 : 8;
+      const scoredWindows = [];
+
+      const scorePrompt = (batch) => {
+        const items = batch.map((w, i) =>
+          `[${i}] ${w.start.toFixed(1)}s-${w.end.toFixed(1)}s:\n"${w.text.slice(0, 400)}"`
+        ).join('\n\n');
+        return `You are a viral short-form video editor. Score each transcript window 1-10 for its potential as a standalone viral clip (hook strength, emotion, surprise, clarity). For the best windows (score >= 7), suggest a punchy 5-8 word title and a one-sentence hook.
+
+Respond ONLY with a JSON array, one object per window, in the same order:
+[{"index":0,"score":7,"title":"Optional title","hook":"Optional hook sentence"},...]
+
+Transcript windows:
+${items}`;
+      };
+
+      const callLlm = (prompt) => new Promise((resolve, reject) => {
+        const body = JSON.stringify(
+          resolvedLlmUrl
+            ? { model: llmModel || 'llama3.1', messages: [{ role: 'user', content: prompt }], response_format: { type: 'json_object' } }
+            : { contents: [{ parts: [{ text: prompt }] }], generationConfig: { responseMimeType: 'application/json' } }
+        );
+        const url = resolvedLlmUrl
+          ? new URL('/v1/chat/completions', resolvedLlmUrl)
+          : new URL(`https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=${resolvedGeminiKey}`);
+        const isHttps = url.protocol === 'https:';
+        const lib = isHttps ? https : http;
+        const options = {
+          hostname: url.hostname,
+          port:     url.port || (isHttps ? 443 : 80),
+          path:     url.pathname + url.search,
+          method:   'POST',
+          headers:  { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+        };
+        const req = lib.request(options, (res) => {
+          let data = '';
+          res.on('data', d => { data += d; });
+          res.on('end', () => {
+            try {
+              const parsed = JSON.parse(data);
+              // Extract text from either Gemini or OpenAI-compat response
+              const text = parsed?.candidates?.[0]?.content?.parts?.[0]?.text
+                        || parsed?.choices?.[0]?.message?.content
+                        || '[]';
+              // Extract JSON array from the text
+              const match = text.match(/\[[\s\S]*\]/);
+              resolve(match ? JSON.parse(match[0]) : []);
+            } catch (e) { resolve([]); }
+          });
+        });
+        req.on('error', reject);
+        req.setTimeout(30000, () => { req.destroy(); reject(new Error('LLM request timed out')); });
+        req.write(body);
+        req.end();
+      });
+
+      for (let i = 0; i < windows.length; i += batchSize) {
+        const batch = windows.slice(i, i + batchSize);
+        try {
+          const scores = await callLlm(scorePrompt(batch));
+          for (const s of scores) {
+            const w = batch[s.index ?? 0];
+            if (w) {
+              scoredWindows.push({
+                ...w,
+                score: Number(s.score) || 5,
+                title: s.title || null,
+                hook:  s.hook  || null,
+              });
+            }
+          }
+        } catch (_) {
+          // If LLM fails, push with neutral score so the tool still returns something
+          for (const w of batch) scoredWindows.push({ ...w, score: 5, title: null, hook: null });
+        }
+      }
+
+      // ── Step 4: Select top N, de-overlap, clamp to clip length ───────────
+      scoredWindows.sort((a, b) => b.score - a.score);
+      const selected = [];
+      for (const w of scoredWindows) {
+        if (selected.length >= clampedTarget) break;
+        // De-overlap: skip if too close to an already-selected clip
+        const tooClose = selected.some(s =>
+          Math.abs(s.start - w.start) < clipMinSeconds * 0.75
+        );
+        if (tooClose) continue;
+        // Clamp to requested length constraints
+        const rawLen = w.end - w.start;
+        const clamped = Math.min(Math.max(rawLen, clipMinSeconds), clipMaxSeconds);
+        selected.push({
+          rank:    selected.length + 1,
+          score:   w.score,
+          start:   parseFloat(w.start.toFixed(2)),
+          end:     parseFloat(Math.min(w.start + clamped, totalDuration).toFixed(2)),
+          duration: parseFloat(clamped.toFixed(2)),
+          title:   w.title || `Clip ${selected.length + 1}`,
+          hook:    w.hook  || null,
+          transcript_preview: w.text.slice(0, 120) + (w.text.length > 120 ? '…' : ''),
+        });
+      }
+
+      // Sort final output by start time (chronological)
+      selected.sort((a, b) => a.start - b.start);
+      selected.forEach((c, i) => { c.rank = i + 1; });
+
+      return {
+        clips:         selected,
+        clipCount:     selected.length,
+        totalDuration: parseFloat(totalDuration.toFixed(2)),
+        windowsScored: scoredWindows.length,
+        transcriptWords: words.length,
+        llmBackend:    resolvedLlmUrl ? 'local' : (resolvedGeminiKey ? 'gemini' : 'none — scores are neutral 5'),
+        message: selected.length > 0
+          ? `Found ${selected.length} viral clip candidate(s) in ${totalDuration.toFixed(0)}s video. Pass each clip's start/end to edit_video (start_time/end_time) to cut them. Add karaoke_subtitles afterwards if you want word-synced captions on the clips.`
+          : 'No high-scoring clips found. Try lowering clipMinSeconds or providing a longer source video.',
+        editVideoHint: selected.map(c =>
+          `{ "video_path": "${videoPath}", "start_time": ${c.start}, "end_time": ${c.end}, "caption": "${c.title}" }`
+        ),
+      };
+    },
+  },
+
+  // ── Tool 32: Karaoke Subtitles ───────────────────────────────────────────
+  // Burns word-synced subtitles into a video clip. Strictly opt-in —
+  // never called automatically; only when the user explicitly asks for captions.
+  karaoke_subtitles: {
+    description: `Burn word-level karaoke-style subtitles into a video clip. Strictly opt-in — only call this when the user explicitly asks for subtitles or captions on a clip. Never add captions automatically.
+
+Uses Whisper to get word-level timestamps, then generates an ASS subtitle file with word-by-word highlighting and burns it into the video with ffmpeg.
+
+Subtitle styles:
+  classic   — white text, black border, bottom-center (TikTok-style)
+  karaoke   — word-by-word highlight: active word is accent colour, rest are white
+  bold_pop  — each word pops in bold with a slight scale (energetic, Reels-style)
+  minimal   — small clean white text, no border (for aesthetic/lo-fi content)
+
+Output is a new video file with subtitles burned in. The source file is NOT modified.`,
+    inputSchema: {
+      type: 'object',
+      required: ['videoPath', 'outputPath'],
+      properties: {
+        videoPath:    { type: 'string', description: 'Path to the source video clip' },
+        outputPath:   { type: 'string', description: 'Path for the output video with burned subtitles' },
+        style:        { type: 'string', enum: ['classic', 'karaoke', 'bold_pop', 'minimal'], default: 'karaoke', description: 'Subtitle visual style (default: karaoke)' },
+        language:     { type: 'string', description: 'BCP-47 language hint for Whisper (e.g. "en", "hi", "ml"). Auto-detected if omitted.' },
+        whisperModel: { type: 'string', default: 'base', enum: ['tiny','base','small','medium'], description: 'Whisper model size' },
+        fontSize:     { type: 'number', default: 72,  description: 'Font size in pixels (default 72 for 1080p portrait)' },
+        accentColor:  { type: 'string', default: '#FFD700', description: 'Highlight colour for the active word in karaoke style (hex, default gold)' },
+        position:     { type: 'string', enum: ['bottom', 'center', 'top'], default: 'bottom', description: 'Vertical position of subtitles' },
+        maxWordsPerLine: { type: 'number', default: 4, description: 'Max words per subtitle line (default 4 — short punchy lines like TikTok)' },
+      },
+    },
+    handler: async ({
+      videoPath, outputPath, style = 'karaoke', language, whisperModel = 'base',
+      fontSize = 72, accentColor = '#FFD700', position = 'bottom', maxWordsPerLine = 4,
+    }) => {
+      const syncFs  = require('fs');
+      const pathMod = require('path');
+      const os      = require('os');
+      const { spawnSync } = require('child_process');
+
+      if (!videoPath || !syncFs.existsSync(videoPath)) {
+        throw new Error(`videoPath does not exist: ${videoPath}`);
+      }
+      syncFs.mkdirSync(pathMod.dirname(pathMod.resolve(outputPath)), { recursive: true });
+
+      // ── Step 1: Transcribe with word-level timestamps ─────────────────────
+      const { transcribeAudio, detectWhisper } = require('../utils/transcribe');
+      const engine = detectWhisper();
+      if (!engine.available) {
+        throw new Error(
+          'Whisper is not installed. Run: pip install openai-whisper  (or: pip install faster-whisper)'
+        );
+      }
+
+      const transcriptResult = await transcribeAudio(videoPath, {
+        model: whisperModel,
+        language,
+        format: 'json',
+      });
+      if (!transcriptResult?.words?.length) {
+        throw new Error('Transcription returned no words. Check that the clip has speech.');
+      }
+
+      const words = transcriptResult.words; // [{ word, start, end }]
+
+      // ── Step 2: Group words into short lines ──────────────────────────────
+      // Each ASS "event" is one line; we highlight the active word within it.
+      const lines = [];
+      let chunk = [];
+      for (const w of words) {
+        chunk.push(w);
+        if (chunk.length >= maxWordsPerLine) {
+          lines.push([...chunk]);
+          chunk = [];
+        }
+      }
+      if (chunk.length) lines.push(chunk);
+
+      // ── Step 3: Build ASS subtitle file ──────────────────────────────────
+      // Convert hex color to ASS BGR format (&H00BBGGRR)
+      const hexToAssBgr = (hex) => {
+        const h = hex.replace('#', '').padEnd(6, '0');
+        const r = h.slice(0, 2); const g = h.slice(2, 4); const b = h.slice(4, 6);
+        return `&H00${b}${g}${r}`.toUpperCase();
+      };
+      const toAssTime = (s) => {
+        const h = Math.floor(s / 3600);
+        const m = Math.floor((s % 3600) / 60);
+        const sec = (s % 60).toFixed(2).padStart(5, '0');
+        return `${h}:${String(m).padStart(2, '0')}:${sec}`;
+      };
+
+      const WHITE  = '&H00FFFFFF';
+      const BLACK  = '&H00000000';
+      const ACCENT = hexToAssBgr(accentColor);
+      const SHADOW = style === 'minimal' ? 0 : 1;
+      const BORDER = style === 'minimal' ? 0 : 3;
+      const BOLD   = style === 'bold_pop' ? -1 : 0;
+      const ALIGN  = position === 'top' ? 8 : position === 'center' ? 5 : 2;
+      const marginV = position === 'top' ? 60 : position === 'center' ? 0 : 80;
+
+      const assHeader = `[Script Info]
+ScriptType: v4.00+
+PlayResX: 1080
+PlayResY: 1920
+WrapStyle: 1
+
+[V4+ Styles]
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+Style: Default,Arial,${fontSize},${WHITE},${ACCENT},${BLACK},&H80000000,${BOLD},0,0,0,100,100,0,0,1,${BORDER},${SHADOW},${ALIGN},60,60,${marginV},1
+
+[Events]
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+`;
+
+      let assEvents = '';
+      for (const line of lines) {
+        const lineStart = line[0].start;
+        const lineEnd   = line[line.length - 1].end;
+
+        if (style === 'karaoke' || style === 'bold_pop') {
+          // One event per word showing the whole line, with the active word highlighted
+          for (let wi = 0; wi < line.length; wi++) {
+            const w = line[wi];
+            const text = line.map((ww, i) => {
+              const clean = ww.word.replace(/[{}\\]/g, '').trim();
+              if (i === wi) {
+                return style === 'bold_pop'
+                  ? `{\\c${ACCENT}\\b-1\\fscx115\\fscy115}${clean}{\\b0\\fscx100\\fscy100\\c${WHITE}}`
+                  : `{\\c${ACCENT}}${clean}{\\c${WHITE}}`;
+              }
+              return clean;
+            }).join(' ');
+            assEvents += `Dialogue: 0,${toAssTime(w.start)},${toAssTime(w.end)},Default,,0,0,0,,${text}\n`;
+          }
+        } else {
+          // classic / minimal: one event per line, no highlight
+          const text = line.map(w => w.word.replace(/[{}\\]/g, '').trim()).join(' ');
+          assEvents += `Dialogue: 0,${toAssTime(lineStart)},${toAssTime(lineEnd)},Default,,0,0,0,,${text}\n`;
+        }
+      }
+
+      const assContent = assHeader + assEvents;
+      const tmpDir  = require('os').tmpdir();
+      const assPath = pathMod.join(tmpDir, `ff_karaoke_${Date.now()}.ass`);
+      syncFs.writeFileSync(assPath, assContent, 'utf8');
+
+      // ── Step 4: Burn subtitles with ffmpeg ────────────────────────────────
+      // Escape path for ffmpeg ass filter (Windows backslashes + colon)
+      const escapedAss = assPath.replace(/\\/g, '/').replace(/:/g, '\\:');
+
+      const result = spawnSync('ffmpeg', [
+        '-nostdin', '-y',
+        '-i', videoPath,
+        '-vf', `ass='${escapedAss}'`,
+        '-c:v', 'libx264', '-preset', 'fast', '-crf', '18',
+        '-profile:v', 'high', '-pix_fmt', 'yuv420p',
+        '-c:a', 'copy',
+        '-movflags', '+faststart',
+        outputPath,
+      ], { timeout: 5 * 60 * 1000, encoding: 'utf8' });
+
+      // Cleanup temp ASS file
+      try { syncFs.unlinkSync(assPath); } catch (_) {}
+
+      if (result.status !== 0) {
+        throw new Error(`ffmpeg subtitle burn failed: ${(result.stderr || '').slice(-400)}`);
+      }
+
+      const stat = syncFs.statSync(outputPath);
+      return {
+        outputPath,
+        style,
+        linesCount:  lines.length,
+        wordsCount:  words.length,
+        duration:    parseFloat((transcriptResult.duration || 0).toFixed(2)),
+        sizeBytes:   stat.size,
+        message:     `Subtitles burned into ${pathMod.basename(outputPath)} (${lines.length} lines, ${words.length} words, style: ${style}). Source file was NOT modified.`,
+      };
+    },
+  },
+
+  // ── Tool 33: List Motion Graphics Styles ────────────────────────────────────────
+  // Returns all 62 styles from FrameForge Motion Library, optionally filtered by family.
+  list_motion_styles: {
+    description: `List all 62 motion-graphics styles from the Motion Graphics Style Library (FrameForge Motion Library/\#library). Each style is a full canvas animation with sound, drawn in code by Claude — zero AI images, zero API keys.
+
+Families: Kinetic Type (3) · Hand-Drawn (3) · Screen and UI (1) · Data (6) · Talking Head (1) · Illustrated (7) · 3D (14) · Retro (2) · Shorts Format (10) · Edit Overlay (10) · Character Story (5).
+
+Use list_motion_styles to discover which style fits the content, then call get_motion_style_prompt to get the full Claude prompt for that style.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        family: {
+          type: 'string',
+          description: 'Filter by family (case-insensitive). One of: Kinetic Type, Hand-Drawn, Screen and UI, Data, Talking Head, Illustrated, 3D, Retro, Shorts Format, Edit Overlay, Character Story. Omit to return all 62.',
+        },
+        search: {
+          type: 'string',
+          description: 'Free-text search in style name or look description (case-insensitive).',
+        },
+      },
+    },
+    handler: ({ family, search } = {}) => {
+      const syncFs  = require('fs');
+      const pathMod = require('path');
+      const catalogPath = pathMod.resolve(__dirname, '../../plugins/motion-styles/catalog.json');
+      if (!syncFs.existsSync(catalogPath)) {
+        throw new Error(`Motion Graphics catalog not found at ${catalogPath}. Re-clone the FrameForge repo.`);
+      }
+      let styles = JSON.parse(syncFs.readFileSync(catalogPath, 'utf8'));
+      if (family) {
+        const fam = family.trim().toLowerCase();
+        styles = styles.filter(s => s.family.toLowerCase().includes(fam));
+      }
+      if (search) {
+        const q = search.trim().toLowerCase();
+        styles = styles.filter(s =>
+          s.name.toLowerCase().includes(q) ||
+          (s.look || '').toLowerCase().includes(q) ||
+          (s.how || '').toLowerCase().includes(q)
+        );
+      }
+      return {
+        styles: styles.map(s => ({
+          id:         s.id,
+          num:        s.num,
+          name:       s.name,
+          family:     s.family,
+          look:       s.look,
+          canvas:     s.canvas || '1280x720',
+          three:      Boolean(s.three),
+          footage:    Boolean(s.footage),
+          demo:       s.demo || null,
+          fonts:      s.fonts || null,
+          promptFile: s.promptFile || `prompts/${s.id}.md`,
+          sourceFile: s.sourceFile || `sources/${s.id}.html`,
+        })),
+        count: styles.length,
+        totalInLibrary: 62,
+        catalogPath,
+        message: `${styles.length} style(s) matched. Call get_motion_style_prompt with a style id to get the full Claude prompt.`,
+      };
+    },
+  },
+
+  // ── Tool 34: Get Motion Style Prompt ──────────────────────────────────────
+  // Returns the complete Claude prompt for one Motion graphics style — paste it into
+  // a new Claude chat to get that exact look for your own content.
+  get_motion_style_prompt: {
+    description: `Get the complete Claude prompt for a Motion graphics style. Paste it into a new Claude chat to get that exact motion-graphics look built around your own content or timing.
+
+The prompt includes: the full look description, how each beat works, font specs, what to replace (your data), what to keep (the kit helpers), size rules, voiceover timing rules, sheet (visual) rules, and sound design rules. Optionally includes full reference source HTML code.
+
+Get a style id from list_motion_styles first. Source: FrameForge Motion Library — prompts are free to use for your own videos.`,
+    inputSchema: {
+      type: 'object',
+      required: ['styleId'],
+      properties: {
+        styleId: {
+          type: 'string',
+          description: 'Style id from list_motion_styles (e.g. "creator-motion", "chalk-talk", "clay-diorama"). Use the exact id field, not the name.',
+        },
+        topic: {
+          type: 'string',
+          description: 'Optional: your topic or voiceover subject. If provided, it is injected into the prompt as context.',
+        },
+        mode: {
+          type: 'string',
+          enum: ['standard', 'vo'],
+          description: 'Optional: "standard" for direct build or "vo" for word-level voiceover timing and narration mix.',
+        },
+        storyboard: {
+          type: 'boolean',
+          description: 'Optional: if true, prompt requests a 6-10 panel storyboard first before building full animation.',
+        },
+        includeSource: {
+          type: 'boolean',
+          description: 'Optional: if true, embeds the complete standalone reference source HTML file in the prompt.',
+        },
+      },
+    },
+    handler: ({ styleId, topic, mode = 'standard', storyboard = false, includeSource = false } = {}) => {
+      const syncFs  = require('fs');
+      const pathMod = require('path');
+      const catalogPath = pathMod.resolve(__dirname, '../../plugins/motion-styles/catalog.json');
+      if (!syncFs.existsSync(catalogPath)) {
+        throw new Error(`Motion Graphics catalog not found at ${catalogPath}. Re-clone the FrameForge repo.`);
+      }
+      const styles = JSON.parse(syncFs.readFileSync(catalogPath, 'utf8'));
+      const style = styles.find(s => s.id === styleId || s.num === styleId || s.name.toLowerCase() === (styleId || '').toLowerCase());
+      if (!style) {
+        const ids = styles.map(s => s.id).join(', ');
+        throw new Error(`Style "${styleId}" not found. Available ids: ${ids}`);
+      }
+
+      // Check for standalone prompt file or source HTML
+      const promptFilePath = pathMod.resolve(__dirname, `../../plugins/motion-styles/prompts/${style.id}.md`);
+      const sourceFilePath = pathMod.resolve(__dirname, `../../plugins/motion-styles/sources/${style.id}.html`);
+      let sourceCode = '';
+      if (includeSource && syncFs.existsSync(sourceFilePath)) {
+        sourceCode = syncFs.readFileSync(sourceFilePath, 'utf8');
+      }
+
+      // Build the prompt matching FrameForge Motion Library builder
+      const isVo = mode === 'vo';
+      const intro = `I want an animated video in the "${style.name}" style (${style.family}) from the Motion Graphics Style Library. Below is a complete, working reference animation in this style: its core helpers (CM), a synthesized sound kit (SFX), the style's scenes, its sound score and the player page. Treat that file as the ground truth for how this style looks, moves and sounds, and rebuild it around my content.`;
+      const topicText = topic ? topic.trim() : '[No topic yet. Ask me for my topic or script before building anything.]';
+      const timingSection = isVo ? `\nVOICEOVER TIMING\n[No timing pasted yet. Before building, ask me for a word-level SRT or word timestamps of my voiceover. If I only have the audio file, offer to transcribe it into word timings.]\n\nHow to use the timing:\n- Turn it into a list of words with start and end times in seconds. If the timing is per line only, spread each line's words across its span in proportion to their length.\n- Set the duration to the last word's end plus about 1.2 seconds.\n- Build the timeline (TL) from these times. ${style.voLine || ''}\n- Cut between scenes only at idea boundaries (a new step, a new claim, a reveal), never mid-word, and finish each cut just before the next idea's first spoken word.\n- Put the emphasis moves on stressed words. A counter lands at the exact moment its number is spoken.\n- Keep the player's "Load voiceover" button working so I can drop in my audio and hear it in sync.\n` : '';
+
+      const workflowSection = storyboard ? `STORYBOARD FIRST\nBefore building, show me a storyboard and wait for my OK:\n- One HTML page (an artifact if you can) with a grid of 6 to 10 panels, one per beat. Draw each panel on a canvas with the reference's own helpers, scene drawing and finishing pass, so the stills already look like the finished piece. No animation or sound yet.\n- Under each panel: the beat number, its start and end time, the exact on-screen words, the camera move or emphasis, how it gets there from the previous beat (the same scene continuing, or a cut and which kind), and its key sounds.\n- Below the grid, list any facts or numbers you had to assume.\nWhen I approve it (or after my changes), build the full animation and reuse the storyboard's drawing code.` : `BUILD DIRECTLY\nSkip the storyboard and build the full animation now. Afterwards, list any facts or numbers you assumed.`;
+
+      const buildSection = `WHAT TO BUILD\nOne self-contained HTML file (an artifact if you can), built on the reference file below:\n- Keep the page, the player (play/pause, scrub, time, sound toggle, loop, Load voiceover${style.footage ? ', Load footage' : ''}) and the CM and SFX blocks unchanged.${style.lib ? ' Also keep the shared library helpers block (track, txt, chip, slam, rise, wordLine, hd, footage, composite, cam, punch, makeGL and the sound helpers) unchanged.' : ''}${style.canvas ? `\\n- Keep the canvas at ${style.canvas} (9:16, for Shorts, Reels and TikTok).` : ''}${style.three ? '\\n- Keep the Three.js r128 script tag and build every 3D object in code: no models or textures from the web.' : ''}${style.footage ? '\\n- Keep window.loadFootage(url) and the Load footage button working so I can drop in my own clip and see the overlay on it; until then the stand-in presenter shows where I sit in the frame.' : ''}\n- Replace the demo's story: ${style.replace || ''}. Keep and reuse the style's helpers (${style.keep || ''}).\n- Aim for 15 to 40 seconds unless my content needs more, and set the duration in TL.D.\n- Keep window.seek(t), window.DURATION, window.scoreSound and window.SFX exposed, so the video can be rendered frame by frame.\n- Load the style's fonts before the first draw, as the reference does: ${style.fonts || ''}.`;
+
+      const sheetRules = Array.isArray(style.sheet) ? '\nTHE STYLE\n' + style.sheet.map(r => '- ' + r).join('\n') : '';
+      const sizeRules = `\nRULES THAT KEEP IT IN STYLE\n- Change the story, the words and the props; do not change the medium. Draw every subject accurately for my topic and double-check any facts and numbers you show.\n- Every frame is a pure function of t. Use CM.rng(seed) and CM.noise1(seed) for all randomness, never Math.random. Caching static layers is fine.\n- It will be watched on phones: at ${style.canvas || '1280x720'} ${style.sizes || ''}. Fill the frame.\n- Keep each frame fast, well under 50 ms.\n- Give my topic its own demo content; do not reuse the reference's story ("${style.demo || ''}") unless my content asks for it.`;
+
+      const soundRules = Array.isArray(style.sound) ? '\nSOUND\n' + style.sound.map(r => '- ' + r).join('\n') + '\n' + (isVo ? (style.voMix || '') : (style.full || '')) + '\n- Sync is everything: the sound score reads the same TL times as the picture.' : '';
+
+      const renderSection = `\nIF YOU CAN RUN CODE\nRender an MP4: open the file in headless Chrome, call window.seek(i / 30) for every frame, capture the canvas and pipe the frames into ffmpeg. Render the effects with SFX.render(window.scoreSound, window.DURATION, 48000, { voiceover: false }), which returns interleaved stereo floats, and mux them in. With a voiceover, render the effects with { voiceover: true } and mix them under my audio file.`;
+
+      const styleCard = `\nSTYLE CARD\nName: ${style.name}\nFamily: ${style.family}\nLook: ${style.look}\nHow it explains: ${style.how || ''}`;
+
+      let prompt = `${intro}\n\nMY CONTENT\n${topicText}\n${timingSection}\n${workflowSection}\n\n${buildSection}\n${sheetRules}\n${sizeRules}\n${soundRules}\n${renderSection}\n${styleCard}`;
+
+      if (includeSource && sourceCode) {
+        prompt += `\n\nREFERENCE SOURCE (the complete working file)\n\`\`\`html\n${sourceCode.trim()}\n\`\`\``;
+      }
+
+      return {
+        styleId:     style.id,
+        num:         style.num,
+        name:        style.name,
+        family:      style.family,
+        canvas:      style.canvas || '1280x720',
+        three:       Boolean(style.three),
+        footage:     Boolean(style.footage),
+        prompt,
+        promptLength: prompt.length,
+        promptPath:  `plugins/motion-styles/prompts/${style.id}.md`,
+        sourcePath:  `plugins/motion-styles/sources/${style.id}.html`,
+        source:      'FrameForge Motion Library — free to use for your own videos',
+        message:     `Prompt for "${style.name}" ready (${prompt.length} chars). Copy it and paste into a new Claude chat${topic ? ` with topic: "${topic}"` : ''}.`,
+      };
+    },
+  },
+
 };
 
 // ── MCP protocol handler (MCP 2024-11-05 spec) ───────────────────────────
 
 const SERVER_INFO = {
   name:    'video-pipeline',
-  version: '2.7.3',
+  version: '2.7.7',
 };
 
 const CAPABILITIES = {