@amg555/frameforge-mcp 2.3.0 → 2.3.2

package/.claude-plugin/marketplace.json

@@ -1,17 +1,45 @@
 {
   "name": "frameforge",
-  "owner": { "name": "AMG555" },
-  "metadata": {
-    "description": "FrameForge — Enterprise AI video production engine. Localhost-first, any agentic IDE (IBM Bob, Cursor, Windsurf, Kiro, Claude Code). Cloudflare Remote MCP for ~80% token savings.",
-    "version": "1.2.0"
-  },
+  "displayName": "FrameForge — AI Video Production",
+  "description": "Full AI video production engine. Produce short-form reels (1080×1920), YouTube videos (1920×1080), or code-driven animated explainers — directly from your IDE. Playwright + FFmpeg renders every frame. 17 MCP tools.",
+  "version": "2.3.1",
+  "homepage": "https://github.com/AMG555/FrameForge",
   "plugins": [
     {
       "name": "video-pipeline",
-      "source": "./plugins/video-pipeline",
-      "description": "End-to-end overnight video production: topic research with real fact-checking (Tavily/Brave/SearXNG), script writing, voice synthesis (ElevenLabs/edge-tts/Azure/OpenAI), FFmpeg animation, quality gates, file and webhook delivery.",
-      "version": "2.3.0",
-      "keywords": ["frameforge", "video", "automation", "mcp", "tts", "ffmpeg", "ibm-bob", "enterprise", "cloudflare"]
+      "path": "plugins/video-pipeline/.claude-plugin/plugin.json",
+      "skills": [
+        {
+          "name": "video-pipeline",
+          "displayName": "FrameForge Video Pipeline",
+          "description": "End-to-end video production: research → script → TTS → images → render → publish. Three paths: (1) IDE writes scenes (most common, no API key), (2) code-driven Playwright animation, (3) auto-research pipeline. 17 MCP tools.",
+          "triggerPhrases": [
+            "make a video about",
+            "produce a reel on",
+            "create a short",
+            "edit this into a reel",
+            "make an explainer",
+            "animated video",
+            "code-driven video",
+            "generate video",
+            "run the pipeline",
+            "publish video",
+            "overnight batch",
+            "queue videos"
+          ]
+        }
+      ]
     }
-  ]
+  ],
+  "mcpServer": {
+    "command": "npx",
+    "args": ["--yes", "--package=@amg555/frameforge-mcp", "frameforge-mcp"],
+    "description": "Runs the FrameForge MCP server via npx (no install needed). Requires ffmpeg and edge-tts on PATH."
+  },
+  "requirements": {
+    "node": ">=18.0.0",
+    "binaries": ["ffmpeg", "ffprobe"],
+    "optional": ["edge-tts", "python3"],
+    "notes": "edge-tts: pip install edge-tts. Playwright (for code-driven animation): npm install playwright && npx playwright install chromium (run once in project dir)."
+  }
 }

package/CHANGELOG.md

@@ -4,6 +4,41 @@ All notable changes to FrameForge are documented here.
 
 ---
 
+## [2.3.2] — 2026-11-06
+
+### Added
+
+- **Tool 18: `export_to_editor`** — send a finished animation MP4 + EDL to any local editing app via an HTTP bridge: Premiere Pro (`:7777`), DaVinci Resolve (`:8080`), CapCut (`:9090`), After Effects (`:7878`), or Remotion (`:3001`). Pass `editorUrl` to override any port. Bridge setup docs: `docs/editor-bridges/`.
+- **VoxForge TTS provider** (`PROVIDER_TTS=voxforge`) — named first-class provider in `TTSProvider`. Tries `/v1/audio/speech` (OpenAI-compatible) then falls back to `/v1/tts`. Configured via `VOXFORGE_URL`, `VOXFORGE_KEY`, `VOXFORGE_VOICE`, `VOXFORGE_MODEL`. Also surfaced in `multi_voice_tts` platform enum and `setup-keys.js` wizard.
+- **Editing app presets in `ExternalAdapter`** — `premiere`, `resolve`, `capcut`, `aftereffects` (local bridge), `kling` (cloud), plus updated `voxforge` preset pointing to `/v1/audio/speech`.
+- **`render_animation` mode `"kit"`** — now exposed in the MCP tool enum. Generates an EDL file in `out/` for import into Premiere / Resolve.
+
+### Changed
+
+- **`CLAUDE.md`**: code-driven animation promoted to **primary path**; FFmpeg + AI images demoted to "quick draft"; new sections for VoxForge voice and editor bridge workflow; tool table reorganised into Primary / Secondary / Auto-research groups (18 tools).
+- **`START_HERE.md`**: opening question set updated to surface animated explainer as a first-class format choice.
+- **`setup-keys.js`**: VoxForge added to TTS provider menu (second option, right after edge-tts). Four new config keys persisted: `VOXFORGE_URL`, `VOXFORGE_KEY`, `VOXFORGE_VOICE`, `VOXFORGE_MODEL`.
+- **`scripts/deep-validate.js`**: +3 checks (`export_to_editor`, `voxforge`, tool count label updated to 18).
+- Version bump: `2.3.1` → `2.3.2` across all version strings.
+
+---
+
+## [2.3.1] — 2026-11-04
+
+### Added
+
+- **`.claude-plugin/marketplace.json`** — Claude Code plugin marketplace registration. FrameForge is now discoverable via `claude plugin marketplace add AMG555/FrameForge`.
+- **`plugins/video-pipeline/.claude-plugin/plugin.json`** — per-plugin manifest for the video-pipeline skill.
+
+### Changed
+
+- **`src/cli/setup-keys.js`** — `skip` is now the **default** option in the LLM provider menu. Users who write their own scenes (the most common path) are no longer forced through an API key section.
+- **`CLAUDE.md`** — Path 2 expanded: transcript/`cuePhrase()` word-sync workflow, `video_job.py` spend-capped batch, golden stills regression test, hook variants (A/B testing opening shots), mobile crop check, still-review budget.
+- **`START_HERE.md`** — restructured into three named paths (A: IDE-scenes, B: code-driven animation, C: auto-research). Reel vs. YouTube format choice surfaced in opening questions. Path B includes transcription, hook variants, and storyboard gate.
+- Version bump: `2.3.0` → `2.3.1` across all version strings.
+
+---
+
 ## [2.3.0] — 2026-11-02
 
 ### Added

package/CLAUDE.md

@@ -58,7 +58,9 @@ If you're not sure what a tool does — call it with the obvious parameters. The
 
 ## THREE PATHS — PICK ONE
 
-### Path 1 — You write the scenes (default, no LLM key needed)
+> **The primary path is Path 2 (code-driven animation).** Every frame is a pure function of time `t`, rendered by Playwright + FFmpeg. This is what produces the high-quality, viral-style motion graphics clips. Path 1 (FFmpeg + AI images) is the fast fallback when Playwright is unavailable or the user wants a quick draft. Path 3 (auto-research) is for unattended batch.
+
+### Path 1 — You write the scenes + AI images (quick draft)
 
 Your IDE model writes the scenes. FrameForge generates TTS + AI images + renders with FFmpeg.
 
@@ -94,10 +96,14 @@ Output files appear in `.frameforge-files/`:
 
 ### Path 2 — Code-driven animated video (Playwright + FFmpeg, no AI images)
 
-Use this when: the user wants motion graphics, Pollinations is unavailable, or they ask for "animated" or "code-rendered" video. Every frame is a pure function of time `t`.
+Use this when: the user wants motion graphics, Pollinations is unavailable, or they ask for "animated", "code-rendered", "explainer", "reel", or "YouTube-style" video. Every frame is a pure function of time `t`.
 
 > **Iron rule:** Never use `Math.random()`, `Date.now()`, `setTimeout`, or module-level mutable state in scene code. Use `hash(i)` from `reel/engine.js` for deterministic randomness.
 
+**Pick a format first:**
+- **Reel / Short / TikTok** → `width: 1080, height: 1920` (portrait 9:16)
+- **YouTube / Explainer** → `width: 1920, height: 1080` (landscape 16:9)
+
 **Step 0 — Beat sheet first. Always. No exceptions.**
 
 Before writing any scene code, reply to the user with:
@@ -106,17 +112,22 @@ Before writing any scene code, reply to the user with:
 
 **Stop and wait for approval before Step 1.** Fixing a beat sheet costs one message. Rewriting a finished scene costs everything.
 
-**Step 1 — Generate TTS first (exact timing is ground truth):**
+**Step 1 — Generate TTS and transcription (exact timing is ground truth):**
 ```
 multi_voice_tts({ text: "Full narration text.", outputPath: ".frameforge-files/voice_0.m4a" })
 ```
+Then transcribe for word-level timestamps (required for `cuePhrase()` sync):
+```
+// run in projectDir after scaffold: python scripts/transcribe.py .frameforge-files/voice_0.m4a
+// → produces voice_0.captions.json with per-word start/end times
+```
 
 **Step 2 — Scaffold the project:**
 ```
 scaffold_animation_project({
   outDir: ".frameforge-files/my-animation/",
   title: "My Video",
-  width: 1920, height: 1080,
+  width: 1920, height: 1080,   // or 1080×1920 for portrait reel
   scenes: [{ narration: "...", caption: "...", visual_description: "..." }],
   audioPath: ".frameforge-files/voice_0.m4a"
 })
@@ -138,16 +149,49 @@ validate_storyboard({ storyboardPath: ".frameforge-files/my-animation/STORYBOARD
 - Read `ANIMATION_GUIDE.md` in the project folder first
 - Every style must be a **pure function of `t`**
 - Use `layer('name').on(t => ({ ...styles }))` for each scene
+- Sync animation to narration using `cuePhrase('the exact words spoken')` — this reads `voice_0.captions.json` and returns the frame when those words start. **The build fails if the phrase isn't found**, so re-recording VO can never silently desync the animation.
 
 **Step 5 — Pre-flight, then stills, then full render:**
 ```
 render_animation({ projectDir: ".frameforge-files/my-animation/", mode: "look" })       // fonts, assets, NaN checks
 render_animation({ projectDir: ".frameforge-files/my-animation/", mode: "sheet" })      // contact sheet — inspect this
 render_animation({ projectDir: ".frameforge-files/my-animation/", mode: "strip", timestamps: [2.1, 2.6] })  // motion check
+render_animation({ projectDir: ".frameforge-files/my-animation/", mode: "crop", timestamps: ["9:16", 3.0] })  // mobile check
 render_animation({ projectDir: ".frameforge-files/my-animation/", mode: "full",
                    audioPath: ".frameforge-files/voice_0.m4a" })                         // only after stills pass
 ```
 
+**Still review budget (minimum, before full render):**
+- At least one `sheet` per shot
+- One `strip` per key motion or transition
+- One `crop` per story-carrying face or detail
+
+**Step 6 — Optional: hook variants**
+
+For reels and Shorts, make 2–3 versions with different opening hooks:
+- Change only the first shot (0s–3s) in `edit.js`
+- `render_animation({ mode: "stills", timestamps: [0.0, 1.5, 3.0] })` to compare openings
+- Full render each variant, deliver as `hook_a.mp4`, `hook_b.mp4`, etc.
+
+**Step 7 — Optional: unattended / spend-capped batch**
+```
+// run from projectDir
+python scripts/video_job.py submit --spec spec.json --max-usd 2.00
+// → { jobId }  — detached process, survives your session closing
+python scripts/video_job.py status --id <jobId>
+python scripts/video_job.py result --id <jobId>
+```
+Each step only starts if the running cost won't exceed `--max-usd`. Receipts go to `jobs/receipts.jsonl`.
+
+**Step 8 — Golden stills regression test (before any refactor)**
+
+After the video passes QC, save the test stills:
+```
+render_animation({ projectDir, mode: "storyboard" })  // 4 keyframes, file to out/storyboard.jpg
+// → copy out/storyboard.jpg to test/golden/storyboard.jpg
+```
+Before future refactors, re-run and compare. If pixels shift, the refactor broke determinism.
+
 > Requires one-time setup in the project directory: `npm install playwright && npx playwright install chromium`
 
 ---
@@ -165,9 +209,20 @@ get_job_status({ jobId })   // poll every 30s until status = "SUCCEEDED"
 
 ---
 
-## ALL 17 MCP TOOLS
+## ALL 18 MCP TOOLS
 
-**No LLM key needed:**
+**Primary — code-driven animation (no LLM key, no image gen API):**
+
+| Tool | What it does |
+|------|-------------|
+| `scaffold_animation_project` | Scaffold a Playwright + FFmpeg animation project (engine, render scripts, STORYBOARD.md) |
+| `validate_storyboard` | Enforce the 4 hard gates before any scene code |
+| `render_animation` | Playwright renderer: `sheet` / `strip` / `storyboard` / `crop` / `full` / `mux` / `kit` / `look` |
+| `multi_voice_tts` | TTS per-call: `edge-tts` · **`voxforge`** · `elevenlabs` · `azure` · `openai` · `webhook` |
+| `export_to_editor` | Send finished animation to Premiere / Resolve / CapCut / After Effects / Remotion |
+| `external_platform_call` | HTTP bridge to VoxForge, Runway, Kling, Pika, or any platform |
+
+**Secondary — FFmpeg + AI images (fast draft, no Playwright needed):**
 
 | Tool | What it does |
 |------|-------------|
@@ -177,15 +232,10 @@ get_job_status({ jobId })   // poll every 30s until status = "SUCCEEDED"
 | `edit_scenes` | Patch captions, swap media files, append scenes |
 | `assemble_video` | FFmpeg render + quality gate → master MP4 |
 | `render_tts` | Generate voice audio for one scene |
-| `multi_voice_tts` | Override TTS provider per call without touching `.env` |
 | `generate_scene_image` | Generate one scene image |
 | `publish_video` | Deliver via file copy or HTTP webhook |
-| `external_platform_call` | HTTP bridge to ElevenLabs, Runway, Replicate, etc. |
-| `scaffold_animation_project` | Create a code-driven animation project |
-| `validate_storyboard` | Check STORYBOARD.md against the 4-gate contract |
-| `render_animation` | Playwright renderer: sheet / strip / storyboard / crop / full / look |
 
-**Needs a free LLM key:**
+**Auto-research (needs a free LLM key):**
 
 | Tool | What it does |
 |------|-------------|
@@ -196,6 +246,56 @@ get_job_status({ jobId })   // poll every 30s until status = "SUCCEEDED"
 
 ---
 
+## VOICE — VoxForge custom audio
+
+`multi_voice_tts` with `platform: "voxforge"` routes to your VoxForge instance:
+
+```
+multi_voice_tts({
+  text: "Your narration.",
+  outputPath: ".frameforge-files/voice_0.m4a",
+  platform: "voxforge",
+  voice: "my-cloned-voice-id",   // speaker ID from VoxForge
+  apiKey: "vf-..."               // or set VOXFORGE_KEY in .env
+})
+```
+
+Set in `.env` for all calls:
+```
+PROVIDER_TTS=voxforge
+VOXFORGE_URL=https://api.voxforge.io    # or your self-hosted URL
+VOXFORGE_KEY=vf-...
+VOXFORGE_VOICE=my-cloned-voice-id
+```
+
+---
+
+## EDITOR BRIDGES — send animation to editing apps
+
+After `render_animation full`, send the finished MP4 into any editing app:
+
+```
+// Export EDL timeline first (for apps that support it)
+render_animation({ projectDir: "...", mode: "kit" })
+
+// Send to DaVinci Resolve (default bridge port :8080)
+export_to_editor({ projectDir: "...", editor: "resolve" })
+
+// Send to Premiere Pro (bridge port :7777)
+export_to_editor({ projectDir: "...", editor: "premiere" })
+
+// Send to CapCut (bridge port :9090)
+export_to_editor({ projectDir: "...", editor: "capcut" })
+
+// Custom endpoint
+export_to_editor({ projectDir: "...", editor: "custom", editorUrl: "http://localhost:4000" })
+```
+
+Bridge servers run locally alongside the app. Setup docs: `docs/editor-bridges/`.
+Override ports: `RESOLVE_BRIDGE_URL`, `PREMIERE_BRIDGE_URL`, `CAPCUT_BRIDGE_URL`, `AE_BRIDGE_URL`.
+
+---
+
 ## SCENE FIELDS
 
 | Field | Required | Notes |

package/README.md

@@ -6,9 +6,10 @@
 
 **Any IDE. Any topic. Any style. 1080p videos from a single prompt.**
 
+[![npm](https://img.shields.io/npm/v/@amg555/frameforge-mcp.svg?label=npm)](https://www.npmjs.com/package/@amg555/frameforge-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org/)
-[![Version](https://img.shields.io/badge/version-2.3.0-blue.svg)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-2.3.2-blue.svg)](CHANGELOG.md)
 [![MCP Spec](https://img.shields.io/badge/MCP-2024--11--05-blue.svg)](https://modelcontextprotocol.io/)
 [![Tests](https://img.shields.io/badge/tests-512%20passing-brightgreen.svg)](#testing)
 
@@ -272,6 +273,16 @@ Every video passes 7 checks before delivery. Any failure blocks the output.
 
 ## CLI commands
 
+**Via npx (no clone needed):**
+
+| Command | What it does |
+|---------|-------------|
+| `npx --package=@amg555/frameforge-mcp frameforge-setup` | Interactive key wizard — saves to `~/.frameforge/config.json` |
+| `npx --package=@amg555/frameforge-mcp frameforge-doctor` | Check Node, FFmpeg, edge-tts, and env vars |
+| `npx --package=@amg555/frameforge-mcp frameforge --topic "..."` | Full pipeline: research → render → deliver |
+
+**Via cloned repo:**
+
 | Command | What it does |
 |---------|-------------|
 | `npm run doctor` | Check Node, FFmpeg, edge-tts, and env vars |
@@ -323,7 +334,14 @@ Report vulnerabilities: [SECURITY.md](SECURITY.md)
 
 ## Deployment
 
-**VPS / Pi / local machine:**
+**npx (no install — recommended for users):**
+
+```bash
+npx --package=@amg555/frameforge-mcp frameforge-setup
+# then add the IDE config from the quickstart above
+```
+
+**VPS / Pi / self-hosted (cloned repo):**
 
 ```bash
 git clone https://github.com/AMG555/FrameForge.git && cd FrameForge

package/START_HERE.md

@@ -17,18 +17,20 @@ produce it — from research through render to final MP4.
 
 ## Opening Message (say this verbatim to the user)
 
-> 👋 I'm your FrameForge video studio. I can make short-form reels, YouTube explainers,
-> documentary clips, tutorials, or any video you describe — using AI research, voiceover,
-> animated scenes, and a full render pipeline.
+> 👋 I'm your FrameForge video studio. I can make:
 >
-> Let's start with a few quick questions so I know exactly what to build:
+> - **Short-form reels** (Instagram, TikTok, YouTube Shorts — 15–60s, 9:16 portrait)
+> - **YouTube videos** (explainers, tutorials, long-form — 3–15 min, 16:9 landscape)
+> - **Code-driven animated explainers** (motion graphics, no stock images needed — any length)
+>
+> Let's start with a few quick questions:
 >
 > 1. **What's the topic or idea?** (e.g. "How black holes form", "5 tips for sourdough bread", "A travel reel about Tokyo")
-> 2. **What style?** Pick one: `educational` · `comedic` · `documentary` · `vlog` · `cinematic` · `tutorial` · or describe your own
-> 3. **How long?** `Short (15–60s)` · `Medium (1–3 min)` · `Long (5–10 min)`
-> 4. **Orientation?** `Landscape 16:9 (YouTube/desktop)` · `Portrait 9:16 (Reels/TikTok/Shorts)`
+> 2. **Format?** `Reel / Short / TikTok (9:16)` · `YouTube video (16:9)` · `Animated explainer (any)`
+> 3. **Style?** `educational` · `comedic` · `documentary` · `cinematic` · `tutorial` · or describe your own
+> 4. **How long?** `Short (15–60s)` · `Medium (1–3 min)` · `Long (5–10 min)`
 > 5. **Voice?** `Auto-select` · or name a style: `professional narrator`, `friendly teacher`, `energetic host`
-> 6. **Any images or clips you want included?** (paste file paths, or say "no — generate everything")
+> 6. **Any footage, images, or audio to include?** (paste file paths, or say "generate everything")
 >
 > Answer as many or as few as you like. I'll fill in the rest.
 
@@ -36,16 +38,24 @@ produce it — from research through render to final MP4.
 
 ## After the User Answers — Agent Instructions
 
-Once you have the user's answers, proceed as follows. Never skip the beat-sheet gate.
+Once you have the user's answers, choose the right render path and follow it precisely.
+
+---
+
+## Render Paths
 
-### Step 1 — Beat Sheet Gate (MANDATORY, no exceptions)
+### PATH A — IDE-written scenes (fastest, most common)
 
-Before calling any render tool, produce a **beat sheet** in this exact format and
-**stop** — wait for the user to approve it before continuing:
+Use for: any video where you (the IDE agent) write the narration and visual descriptions.
+No LLM key needed — FrameForge generates TTS + AI images and renders with FFmpeg.
+
+**Step A1 — Beat Sheet Gate (MANDATORY)**
+
+Before calling any render tool, produce a beat sheet and **stop** — wait for approval:
 
 ```
 BEAT SHEET — "<title>"
-Duration: Xs  |  Style: <style>  |  Format: <orientation>
+Duration: Xs  |  Style: <style>  |  Format: <landscape/portrait>
 
 Scene 1  [0:00–0:08]  <what happens + what the viewer learns>  →  TRANSITION
 Scene 2  [0:08–0:18]  <what happens + what the viewer learns>  →  TRANSITION
@@ -56,43 +66,89 @@ Voice: <voice description>
 Visual style: <1-sentence description>
 ```
 
-Gate rules — reject and revise the beat sheet if ANY of these are true:
+Gate rules — revise if ANY are true:
 - A scene has no event (action that changes something)
 - Two scenes share the same timestamp range
 - Any seam is missing a transition label
-- The total duration doesn't match the user's requested length ±10%
+- Total duration doesn't match requested length ±10%
 
-Only proceed to Step 2 after the user says **"looks good"**, **"go ahead"**, or equivalent.
+**Step A2 — Render**
 
-### Step 2 — Research (if the topic needs facts)
+```
+create_video_from_script({
+  scenes: [ { narration: "...", caption: "...", visual_description: "...", camera_hint: "zoom_in" } ],
+  title: "My Video",
+  orientation: "landscape",   // "portrait" for Reels/Shorts/TikTok
+  voice: "en-US-BrianNeural", // or use language: "en"
+  withMusic: true
+})
+```
 
-Use `research_topic` to gather verified claims. Skip this for pure creative/style videos.
+**Step A3 — Publish**
 
-### Step 3 — Script
+Ask: "Save locally, or deliver somewhere?" Then call `publish_video`.
 
-Use `write_script` with the beat sheet as the outline. Pass `style`, `format`, and
-`voice` from the user's answers. The script must match the beat sheet scene-for-scene.
+---
 
-### Step 4 — Assets
+### PATH B — Code-driven animated video (motion graphics, explainers, reels)
 
-For each scene, call `generate_scene_image` with a prompt that matches the scene's
-visual description. If the user supplied their own files, use `ingest_media` instead.
+Use for: motion graphics, animated explainers, reels that must look high-quality without stock images.
+Requires one-time: `npm install playwright && npx playwright install chromium` (run in the project dir).
 
-Call `render_tts` for each scene's narration line.
+**Step B1 — Beat sheet first (same gate as Path A — MANDATORY)**
 
-### Step 5 — Render
+**Step B2 — TTS and transcription**
 
-Call `create_video_from_script` (IDE-driven path) or `assemble_video` (pipeline path)
-to produce the final MP4.
+```
+multi_voice_tts({ text: "Full narration.", outputPath: ".frameforge-files/voice_0.m4a" })
+// After scaffolding: python scripts/transcribe.py .frameforge-files/voice_0.m4a
+// → voice_0.captions.json — word timestamps for cuePhrase() sync
+```
 
-After render, call `render_animation` with `mode: "sheet"` to produce a contact-sheet
-preview. Show the user the sheet path and ask if they want any changes.
+**Step B3 — Scaffold**
 
-### Step 6 — Publish (optional)
+```
+scaffold_animation_project({
+  outDir: ".frameforge-files/my-animation/",
+  title: "My Video",
+  width: 1920, height: 1080,   // 1080×1920 for portrait reels
+  scenes: [...],
+  audioPath: ".frameforge-files/voice_0.m4a"
+})
+```
 
-Ask the user: "Do you want to publish this anywhere, or just save the file locally?"
+**Step B4 — Validate STORYBOARD.md**
 
-If they want to publish, call `publish_video` with their chosen channel.
+```
+validate_storyboard({ storyboardPath: ".frameforge-files/my-animation/STORYBOARD.md" })
+```
+
+**Step B5 — Write `edit.js`, then stills, then full render**
+
+```
+render_animation({ projectDir: "...", mode: "look" })           // pre-flight
+render_animation({ projectDir: "...", mode: "sheet" })          // one sheet per shot
+render_animation({ projectDir: "...", mode: "strip", timestamps: [2.1, 2.6] })  // motion check
+render_animation({ projectDir: "...", mode: "full", audioPath: ".frameforge-files/voice_0.m4a" })
+```
+
+**For reels: make 2–3 hook variants** (change only the first 3s of `edit.js`, full-render each):
+```
+render_animation({ projectDir: "...", mode: "stills", timestamps: [0.0, 1.5, 3.0] })
+// deliver hook_a.mp4, hook_b.mp4 so the user can A/B test
+```
+
+---
+
+### PATH C — Auto-research (needs `PROVIDER_LLM` + key in `.env`)
+
+Use for: overnight batch, topics where you want FrameForge to research and script everything.
+
+```
+queue_full_pipeline({ topic: "How GPS works", style: "educational" })
+→ { jobId }
+get_job_status({ jobId })   // poll every 30s
+```
 
 ---
 

package/install.sh

@@ -50,7 +50,7 @@ done
 if command -v edge-tts >/dev/null 2>&1; then
   echo "  edge-tts   $(command -v edge-tts) (free TTS, no key)"
 else
-  echo "  edge-tts   not found — run: npm install -g edge-tts"
+  echo "  edge-tts   not found — run: pip install edge-tts"
 fi
 
 echo

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@amg555/frameforge-mcp",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "FrameForge — AI video production engine for agentic IDEs. npx @amg555/frameforge-mcp. FFmpeg + TTS run on your machine. 17 MCP tools.",
   "publishConfig": {
     "access": "public"
   },
   "main": "src/mcp-server/server.js",
   "bin": {
-    "frameforge":        "src/cli/make.js",
-    "frameforge-mcp":    "src/mcp-server/stdio.js",
-    "frameforge-setup":  "src/cli/setup-keys.js",
+    "frameforge": "src/cli/make.js",
+    "frameforge-mcp": "src/mcp-server/stdio.js",
+    "frameforge-setup": "src/cli/setup-keys.js",
     "frameforge-doctor": "src/cli/doctor.js"
   },
   "scripts": {
@@ -55,6 +55,6 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/AMG555/FrameForge"
+    "url": "git+https://github.com/AMG555/FrameForge.git"
   }
 }

package/src/cli/doctor.js

@@ -89,7 +89,37 @@ if (edgeTts.status === 0) {
   );
 }
 
-// 5. System Font (for video subtitles/captions)
+// 5. Playwright / Chromium (required for code-driven animation — Path 2)
+const playwright = spawnSync('node', ['-e', "require('playwright')"], {
+  encoding: 'utf8', timeout: 5000,
+  // Look in the project's own node_modules first (how it ships in the npm package)
+  cwd: path.resolve(__dirname, '../..'),
+});
+const playwrightGlobal = spawnSync('node', ['-e', "require('playwright')"], {
+  encoding: 'utf8', timeout: 5000,
+});
+const hasPlaywright = playwright.status === 0 || playwrightGlobal.status === 0;
+
+// Check for a locally installed Chromium browser
+const chromiumPaths = [
+  path.join(require('os').homedir(), '.cache', 'ms-playwright'),   // Linux / macOS default
+  path.join(process.env.LOCALAPPDATA || '', 'ms-playwright'),       // Windows
+  path.join(require('os').homedir(), 'Library', 'Caches', 'ms-playwright'), // macOS alt
+];
+const hasChromium = chromiumPaths.some(p => { try { return require('fs').readdirSync(p).length > 0; } catch { return false; } });
+
+if (hasPlaywright && hasChromium) {
+  pass('Playwright', 'playwright package + Chromium browser installed (code-driven animation ready)');
+} else if (hasPlaywright && !hasChromium) {
+  warn('Playwright', 'playwright package found but Chromium browser not installed',
+    'Run in your animation project dir: npx playwright install chromium');
+} else {
+  warn('Playwright', 'Not installed — required for code-driven animation (Path 2)',
+    'Run in your animation project dir: npm install playwright && npx playwright install chromium\n' +
+    '    (Path 1 via create_video_from_script does not need Playwright)');
+}
+
+// 6. System Font (for video subtitles/captions)
 const FONT_CANDIDATES = [
   'C:\\Windows\\Fonts\\arialbd.ttf',
   'C:\\Windows\\Fonts\\calibrib.ttf',

package/src/cli/setup-keys.js

@@ -171,6 +171,15 @@ async function main() {
 This wizard writes your provider API keys to: ${path.resolve(outFile)}
 Keys are never sent anywhere — they stay on your machine.
 Press Enter to accept a default. Ctrl+C to cancel.
+
+  ✅  No keys are required to make videos.
+      Your IDE writes the scenes — FrameForge uses free providers by default:
+        • edge-tts  — free voice (no account)
+        • pollinations — free images (no account)
+        • FFmpeg — free local render (already on your machine)
+
+      You only need keys for the auto-research pipeline (FrameForge writes the
+      script itself). Skip those sections if you plan to write scenes yourself.
 `);
 
   const cfg = {};
@@ -178,22 +187,27 @@ Press Enter to accept a default. Ctrl+C to cancel.
   // ── LLM ──────────────────────────────────────────────────────────────────
   section('1 / 5  —  LLM Provider  (research + script generation)');
   console.log('  Used for: researching topics, writing scripts, fact-checking.');
+  console.log('  ⚡ SKIP THIS if your IDE agent writes the scenes (most common path).');
   console.log('  Free option: Groq (no credit card needed for free tier).\n');
 
   cfg.PROVIDER_LLM = await menu('Choose LLM provider', [
+    ['skip',       '⏭  Skip — I write my own scenes (most common, no key needed)'],
     ['groq',       'Groq — free, fast (llama-3.3-70b). Get key: console.groq.com'],
     ['cerebras',   'Cerebras — fastest inference (2000+ tok/s). Get key: cloud.cerebras.ai'],
+    ['gemini',     'Google Gemini 2.0 Flash — free tier. Get key: aistudio.google.com'],
     ['openrouter', 'OpenRouter — all models with one key. Get key: openrouter.ai'],
     ['anthropic',  'Anthropic Claude Sonnet 4.5. Get key: console.anthropic.com'],
-    ['gemini',     'Google Gemini 2.0 Flash. Get key: aistudio.google.com'],
     ['mistral',    'Mistral Large. Get key: console.mistral.ai'],
     ['together',   'Together AI Llama-3.3-70B-Turbo. Get key: api.together.ai'],
     ['openai',     'OpenAI GPT-4o. Get key: platform.openai.com'],
     ['ollama',     'Ollama — fully local, no key needed. Install: ollama.com'],
     ['webhook',    'Custom/VoxForge/any OpenAI-compatible endpoint'],
-  ], 'groq');
+  ], 'skip');
 
-  if (cfg.PROVIDER_LLM === 'groq') {
+  if (cfg.PROVIDER_LLM === 'skip') {
+    console.log('  ✅  LLM skipped — your IDE will write scenes via create_video_from_script.\n');
+    cfg.PROVIDER_LLM = undefined; // don't write to config
+  } else if (cfg.PROVIDER_LLM === 'groq') {
     cfg.GROQ_API_KEY = await askSecret('  Groq API key (starts with gsk_)');
   } else if (cfg.PROVIDER_LLM === 'cerebras') {
     cfg.CEREBRAS_API_KEY = await askSecret('  Cerebras API key');
@@ -226,13 +240,20 @@ Press Enter to accept a default. Ctrl+C to cancel.
 
   cfg.PROVIDER_TTS = await menu('Choose TTS provider', [
     ['edge-tts',   'edge-tts — free, offline, 400+ voices. No key needed.'],
+    ['voxforge',   'VoxForge — custom voice cloning (github.com/amg555/voxforge). Get key: your VoxForge instance.'],
     ['elevenlabs', 'ElevenLabs — best quality + voice cloning. elevenlabs.io'],
     ['azure',      'Azure Cognitive Speech. portal.azure.com'],
     ['openai',     'OpenAI TTS (uses OPENAI_API_KEY above)'],
-    ['webhook',    'Custom/VoxForge/any TTS endpoint'],
+    ['webhook',    'Custom/any OpenAI-compatible TTS endpoint'],
   ], 'edge-tts');
 
-  if (cfg.PROVIDER_TTS === 'elevenlabs') {
+  if (cfg.PROVIDER_TTS === 'voxforge') {
+    cfg.VOXFORGE_URL   = await ask('  VoxForge base URL', 'https://api.voxforge.io');
+    cfg.VOXFORGE_KEY   = await askSecret('  VoxForge API key (leave blank if self-hosted without auth)');
+    cfg.VOXFORGE_VOICE = await ask('  Voice ID or cloned speaker ID', 'narrator');
+    cfg.VOXFORGE_MODEL = await ask('  Model ID (leave blank for default)', 'voxforge-v1');
+    console.log('  ℹ️   Self-hosted? Set VOXFORGE_URL to your instance URL (e.g. http://localhost:8080).');
+  } else if (cfg.PROVIDER_TTS === 'elevenlabs') {
     cfg.ELEVENLABS_API_KEY  = await askSecret('  ElevenLabs API key');
     cfg.ELEVENLABS_VOICE_ID = await ask('  Voice ID (leave blank for default Adam)', 'pNInz6obpgDQGcFmaJgB');
     console.log('  ℹ️   For voice cloning: set ELEVENLABS_VOICE_ID to your cloned voice ID.');
@@ -312,7 +333,7 @@ Press Enter to accept a default. Ctrl+C to cancel.
 
   const groups = {
     '# ── LLM ─────────────────────────────────────────────────────────': ['PROVIDER_LLM','GROQ_API_KEY','CEREBRAS_API_KEY','OPENROUTER_API_KEY','ANTHROPIC_API_KEY','GEMINI_API_KEY','MISTRAL_API_KEY','TOGETHER_API_KEY','OPENAI_API_KEY','OLLAMA_BASE_URL','OLLAMA_MODEL','WEBHOOK_LLM_URL','WEBHOOK_LLM_HEADERS','WEBHOOK_LLM_RESPONSE_PATH','LLM_MODEL'],
-    '# ── TTS ─────────────────────────────────────────────────────────': ['PROVIDER_TTS','ELEVENLABS_API_KEY','ELEVENLABS_VOICE_ID','AZURE_SPEECH_KEY','AZURE_SPEECH_REGION','WEBHOOK_TTS_URL','WEBHOOK_TTS_RESPONSE','WEBHOOK_TTS_RESPONSE_PATH','TTS_VOICE','TTS_RATE'],
+    '# ── TTS ─────────────────────────────────────────────────────────': ['PROVIDER_TTS','VOXFORGE_URL','VOXFORGE_KEY','VOXFORGE_VOICE','VOXFORGE_MODEL','ELEVENLABS_API_KEY','ELEVENLABS_VOICE_ID','AZURE_SPEECH_KEY','AZURE_SPEECH_REGION','WEBHOOK_TTS_URL','WEBHOOK_TTS_RESPONSE','WEBHOOK_TTS_RESPONSE_PATH','TTS_VOICE','TTS_RATE'],
     '# ── Image generation ─────────────────────────────────────────────': ['PROVIDER_IMAGE','FALAI_API_KEY','REPLICATE_API_KEY','WEBHOOK_IMAGE_URL','WEBHOOK_IMAGE_RESPONSE','WEBHOOK_IMAGE_RESPONSE_PATH','POLLINATIONS_MODEL'],
     '# ── Delivery webhooks ────────────────────────────────────────────': ['PUBLISH_WEBHOOK_URL','REVIEW_NOTIFY_URL'],
     '# ── External platform adapter ────────────────────────────────────': ['EXTERNAL_PLATFORM_NAME','EXTERNAL_PLATFORM_URL','EXTERNAL_PLATFORM_KEY','EXTERNAL_PLATFORM_INGEST_PATH','EXTERNAL_PLATFORM_RENDER_PATH','EXTERNAL_PLATFORM_STATUS_PATH'],

package/src/mcp-server/server.js

@@ -592,14 +592,14 @@ Example scene:
   // ── Tool 12: Multi-platform TTS ──────────────────────────────────────────
   // Call any voice platform per-request without changing global .env
   multi_voice_tts: {
-    description: 'Convert text to speech using any supported voice platform per-call. Overrides the global PROVIDER_TTS for this one request. Supports: edge-tts, elevenlabs, azure, openai, custom webhook.',
+    description: 'Convert text to speech using any supported voice platform per-call. Overrides the global PROVIDER_TTS for this one request. Supports: edge-tts, voxforge, elevenlabs, azure, openai, webhook.',
     inputSchema: {
       type: 'object',
       required: ['text', 'outputPath'],
       properties: {
         text:       { type: 'string', description: 'Text to synthesise' },
         outputPath: { type: 'string', description: 'Where to save the audio file (.m4a or .mp3)' },
-        platform:   { type: 'string', enum: ['edge-tts','elevenlabs','azure','openai','webhook'], description: 'TTS platform. Overrides PROVIDER_TTS for this call.' },
+        platform:   { type: 'string', enum: ['edge-tts','voxforge','elevenlabs','azure','openai','webhook'], description: 'TTS platform. Overrides PROVIDER_TTS for this call. "voxforge" = github.com/amg555/voxforge; uses VOXFORGE_URL + VOXFORGE_KEY.' },
         voice:      { type: 'string', description: 'Voice ID. edge-tts: e.g. en-US-GuyNeural. ElevenLabs: voice_id. Azure: short name. OpenAI: alloy/echo/fable/nova/onyx/shimmer.' },
         rate:       { type: 'string', description: 'Speaking rate, e.g. "-10%" for slower, "+20%" for faster (edge-tts)' },
         apiKey:     { type: 'string', description: 'API key for this call (optional — falls back to env var)' },
@@ -608,9 +608,11 @@ Example scene:
         sceneIndex: { type: 'number', description: 'Optional scene index for naming the output file' },
       },
     },
-    handler: async ({ text, outputPath, platform, voice, rate, apiKey, webhookUrl, productionId = 'adhoc', sceneIndex }) => {
+    handler: async ({ text, outputPath, platform: _platform, voice, rate, apiKey, webhookUrl, productionId = 'adhoc', sceneIndex }) => {
       const syncFs  = require('fs');
       const pathMod = require('path');
+      // Normalise platform name so 'voxforge' routes correctly
+      const platform = _platform ? _platform.toLowerCase() : undefined;
 
       // Guard: outputPath must not escape FILES_DIR — prevent path traversal
       if (outputPath) {
@@ -1003,17 +1005,18 @@ Modes:
   "crop"       — focal-point 9:16 mobile crop preview; pass timestamps as [aspect_ratio_string, t]
   "full"       — full render → out/<title>.mp4
   "mux"        — re-mux audio only (no re-render, use after changing audio)
+  "kit"        — export EDL/XML for Premiere Pro / DaVinci Resolve; run after "full"
   "look"       — pre-render linter (fonts, clipped text, NaN transforms, missing assets)
 
 Review budget: at least one "sheet" per shot, one "strip" per key motion/transition, one "crop" per story-carrying face.
-Returns { outputPath, passed } for "full", or { outputPath } for sheet/strip/storyboard.
+Returns { outputPath, passed } for "full", or { outputPath } for sheet/strip/storyboard/kit.
 Requires: npm install playwright && npx playwright install chromium (one-time setup in projectDir).`,
     inputSchema: {
       type: 'object',
       required: ['projectDir', 'mode'],
       properties: {
         projectDir:  { type: 'string', description: 'The directory created by scaffold_animation_project' },
-        mode:        { type: 'string', enum: ['sheet', 'stills', 'strip', 'storyboard', 'crop', 'full', 'mux', 'look'], description: 'Render mode' },
+        mode:        { type: 'string', enum: ['sheet', 'stills', 'strip', 'storyboard', 'crop', 'full', 'mux', 'kit', 'look'], description: 'Render mode' },
         timestamps:  { type: 'array', items: {}, description: 'For mode="stills": [t1, t2, ...]. For mode="strip": [startSeconds, endSeconds]. For mode="crop": ["9:16", t]. For mode="sheet": omit or pass shot times.' },
         audioPath:   { type: 'string', description: 'Audio file to mux in (for mode="full" or "mux")' },
         workers:     { type: 'number', default: 4, description: 'Parallel Playwright pages for mode="full"' },
@@ -1091,6 +1094,9 @@ Requires: npm install playwright && npx playwright install chromium (one-time se
         } else if (mode === 'full' || mode === 'mux') {
           const mp4 = files.find(f => f.endsWith('.mp4') && !f.includes('_preview'));
           if (mp4) outputPath = pathMod.join(outDir, mp4);
+        } else if (mode === 'kit') {
+          const edl = files.find(f => f.endsWith('.edl') || f.endsWith('.xml'));
+          if (edl) outputPath = pathMod.join(outDir, edl);
         } else if (mode === 'stills' || mode === 'strip' || mode === 'crop') {
           const stills = files.filter(f => f.endsWith('.png') || f.endsWith('.jpg'));
           if (stills.length > 0) outputPath = stills.map(f => pathMod.join(outDir, f));
@@ -1114,13 +1120,118 @@ Requires: npm install playwright && npx playwright install chromium (one-time se
     },
   },
 
+  // ── Tool 18: Export to editing app ────────────────────────────────────────
+  // Send a finished animation project to any local editing app via MCP bridge.
+  // Works with Premiere Pro, DaVinci Resolve, CapCut, After Effects, or Remotion.
+  export_to_editor: {
+    description: `Send a finished FrameForge animation to a local editing app for post-production.
+
+Supported editors (configure via env or pass editorUrl directly):
+  "premiere"     — Adobe Premiere Pro via local REST bridge (PREMIERE_BRIDGE_URL, default :7777)
+  "resolve"      — DaVinci Resolve Remote API (RESOLVE_BRIDGE_URL, default :8080)
+  "capcut"       — CapCut Desktop via MCP bridge (CAPCUT_BRIDGE_URL, default :9090)
+  "aftereffects" — Adobe After Effects via AEIO bridge (AE_BRIDGE_URL, default :7878)
+  "remotion"     — Remotion local dev server (REMOTION_BASE_URL, default :3001)
+  "custom"       — any HTTP endpoint (pass editorUrl)
+
+What this does:
+  1. Imports the rendered MP4 (and optionally the audio stem) into the editor
+  2. Exports an EDL/XML timeline from the animation project (render_animation kit mode)
+  3. Returns the editor's import confirmation or render job ID
+
+The bridge servers are lightweight companion apps you run locally alongside the editor.
+They are not installed by FrameForge — see docs/editor-bridges/ for setup instructions.`,
+    inputSchema: {
+      type: 'object',
+      required: ['projectDir'],
+      properties: {
+        projectDir: { type: 'string', description: 'The animation project directory (from scaffold_animation_project)' },
+        editor:     { type: 'string', enum: ['premiere', 'resolve', 'capcut', 'aftereffects', 'remotion', 'custom'], default: 'resolve', description: 'Target editing app' },
+        editorUrl:  { type: 'string', description: 'Override the editor bridge URL (e.g. http://localhost:8080). Useful for custom or remote bridges.' },
+        audioPath:  { type: 'string', description: 'Audio stem to import alongside the video (optional)' },
+        importOnly: { type: 'boolean', default: false, description: 'If true, only import the clip — do not trigger an export/render in the editor.' },
+      },
+    },
+    handler: async ({ projectDir, editor = 'resolve', editorUrl, audioPath, importOnly = false }) => {
+      const syncFs  = require('fs');
+      const pathMod = require('path');
+      const { ExternalAdapter } = require('../pipeline/external-adapter');
+
+      if (!projectDir) throw new Error('projectDir is required');
+      if (!syncFs.existsSync(projectDir)) throw new Error(`Project directory not found: ${projectDir}`);
+
+      // Find the most recently rendered MP4 in out/
+      const outDir = pathMod.join(projectDir, 'out');
+      if (!syncFs.existsSync(outDir)) {
+        throw new Error(`No out/ directory in ${projectDir}. Run render_animation with mode="full" first.`);
+      }
+      const mp4Files = syncFs.readdirSync(outDir)
+        .filter(f => f.endsWith('.mp4') && !f.includes('_preview'))
+        .map(f => pathMod.join(outDir, f))
+        .sort((a, b) => syncFs.statSync(b).mtimeMs - syncFs.statSync(a).mtimeMs);
+
+      if (mp4Files.length === 0) {
+        throw new Error(`No rendered MP4 found in ${outDir}. Run render_animation with mode="full" first.`);
+      }
+      const masterPath = mp4Files[0];
+
+      // Also find the EDL from kit mode (generate it now if missing)
+      const edlFiles = syncFs.readdirSync(outDir).filter(f => f.endsWith('.edl') || f.endsWith('.xml'));
+      let edlPath = edlFiles.length > 0 ? pathMod.join(outDir, edlFiles[0]) : null;
+
+      // Configure the adapter for the target editor
+      // editorUrl overrides the preset base URL
+      const adapterConfig = editorUrl
+        ? { name: editor, baseUrl: editorUrl }
+        : { name: editor };
+
+      const adapter = new ExternalAdapter(adapterConfig);
+
+      // Build the file list to import
+      const files = [masterPath];
+      if (audioPath && syncFs.existsSync(audioPath)) files.push(audioPath);
+      if (edlPath) files.push(edlPath);
+
+      let importResult;
+      try {
+        importResult = await adapter.ingestMedia({
+          files,
+          metadata: {
+            source:    'frameforge',
+            projectDir,
+            editor,
+            importOnly: String(importOnly),
+          },
+        });
+      } catch (err) {
+        // If the bridge is not running, give a clear message instead of a raw HTTP error
+        throw new Error(
+          `Could not reach ${editor} bridge at ${adapter.baseUrl}.\n` +
+          `Make sure the bridge is running.\n` +
+          `Error: ${err.message}\n\n` +
+          `See docs/editor-bridges/${editor}.md for setup instructions.`
+        );
+      }
+
+      return {
+        editor,
+        bridgeUrl: adapter.baseUrl,
+        importedFiles: files.map(f => pathMod.basename(f)),
+        masterPath,
+        edlPath,
+        importResult,
+        message: `Imported into ${editor} at ${adapter.baseUrl}. ${edlPath ? 'EDL/XML timeline included.' : 'Tip: run render_animation mode="kit" to also export an EDL timeline.'}`,
+      };
+    },
+  },
+
 };
 
 // ── MCP protocol handler (MCP 2024-11-05 spec) ───────────────────────────
 
 const SERVER_INFO = {
   name:    'video-pipeline',
-  version: '2.3.0',
+  version: '2.3.2',
 };
 
 const CAPABILITIES = {

package/src/pipeline/external-adapter.js

@@ -150,24 +150,20 @@ class ExternalAdapter {
   _applyPreset() {
     const name = this.name.toLowerCase();
     const presets = {
+      // ── Voice / Audio platforms ─────────────────────────────────────────────
+      voxforge: {
+        baseUrl:    this.baseUrl || process.env.VOXFORGE_URL || 'https://api.voxforge.io',
+        ingestPath: '/v1/voices/add',   // upload a speaker sample for cloning
+        renderPath: '/v1/audio/speech', // OpenAI-compatible TTS synthesis
+        statusPath: '/v1/voices',       // list voices / health check
+      },
       elevenlabs: {
         baseUrl:    'https://api.elevenlabs.io',
-        ingestPath: '/v1/voices/add',                // voice cloning
-        renderPath: '/v1/text-to-speech',            // TTS synthesis
-        statusPath: '/v1/voices',                    // list voices (health check)
-      },
-      remotion: {
-        baseUrl:    process.env.REMOTION_BASE_URL || 'http://localhost:3001',
-        ingestPath: '/compositions',
-        renderPath: '/renders',
-        statusPath: '/renders',
-      },
-      voxforge: {
-        baseUrl:    this.baseUrl || 'https://api.voxforge.io',
-        ingestPath: '/v1/ingest',
-        renderPath: '/v1/render',
-        statusPath: '/v1/status',
+        ingestPath: '/v1/voices/add',
+        renderPath: '/v1/text-to-speech',
+        statusPath: '/v1/voices',
       },
+      // ── Video generation platforms ──────────────────────────────────────────
       runway: {
         baseUrl:    'https://api.runwayml.com',
         ingestPath: '/v1/assets',
@@ -180,6 +176,50 @@ class ExternalAdapter {
         renderPath: '/generate',
         statusPath: '/generations',
       },
+      kling: {
+        baseUrl:    'https://api.klingai.com',
+        ingestPath: '/v1/videos/image2video',
+        renderPath: '/v1/videos/image2video',
+        statusPath: '/v1/videos/image2video',
+      },
+      // ── Local editing app bridges ───────────────────────────────────────────
+      // These talk to local companion servers (CEP panel, local REST shim, etc.)
+      remotion: {
+        baseUrl:    process.env.REMOTION_BASE_URL || 'http://localhost:3001',
+        ingestPath: '/compositions',
+        renderPath: '/renders',
+        statusPath: '/renders',
+      },
+      premiere: {
+        // Adobe Premiere Pro — requires the FrameForge CEP panel (see docs/premiere-panel/)
+        // OR the unofficial premiere-rest-bridge: github.com/premiere-rest-bridge
+        baseUrl:    process.env.PREMIERE_BRIDGE_URL || 'http://localhost:7777',
+        ingestPath: '/import',          // import a clip into the current project
+        renderPath: '/export',          // export timeline to file
+        statusPath: '/status',
+      },
+      resolve: {
+        // DaVinci Resolve — requires local Resolve REST API bridge (port 8080 by default)
+        // Enable via: Preferences → System → Remote Control (DaVinci Resolve 18.6+)
+        baseUrl:    process.env.RESOLVE_BRIDGE_URL || 'http://localhost:8080',
+        ingestPath: '/media/import',
+        renderPath: '/render/start',
+        statusPath: '/render/status',
+      },
+      capcut: {
+        // CapCut Desktop — requires CapCut MCP bridge (https://github.com/capcut-mcp)
+        baseUrl:    process.env.CAPCUT_BRIDGE_URL || 'http://localhost:9090',
+        ingestPath: '/import',
+        renderPath: '/export',
+        statusPath: '/status',
+      },
+      aftereffects: {
+        // Adobe After Effects — requires AEIO REST bridge or ExtendScript server
+        baseUrl:    process.env.AE_BRIDGE_URL || 'http://localhost:7878',
+        ingestPath: '/import',
+        renderPath: '/render',
+        statusPath: '/render/status',
+      },
     };
 
     const preset = presets[name];

package/src/pipeline/providers.js

@@ -390,12 +390,58 @@ class TTSProvider {
       case 'elevenlabs': return this._elevenLabs({ text, voice: resolvedVoice, outputPath });
       case 'azure':      return this._azureTTS({ text, voice: resolvedVoice, outputPath });
       case 'openai':     return this._openaiTTS({ text, voice: resolvedVoice, outputPath });
+      case 'voxforge':   return this._voxforgeTTS({ text, voice: resolvedVoice, outputPath });
       case 'custom':
       case 'webhook':    return this._customTTS({ text, voice: resolvedVoice, outputPath });
       default:           return this._edgeTTS({ text, voice: resolvedVoice, outputPath });
     }
   }
 
+  /**
+   * VoxForge TTS — github.com/amg555/voxforge
+   * OpenAI-compatible /v1/audio/speech endpoint with optional voice cloning.
+   * Env vars:
+   *   VOXFORGE_URL   — base URL, e.g. https://api.voxforge.io  (or self-hosted)
+   *   VOXFORGE_KEY   — API key (Bearer token)
+   *   VOXFORGE_VOICE — voice ID or cloned speaker ID (default: 'narrator')
+   *   VOXFORGE_MODEL — model ID (default: 'voxforge-v1')
+   */
+  async _voxforgeTTS({ text, voice, outputPath }) {
+    const baseUrl = process.env.VOXFORGE_URL || 'https://api.voxforge.io';
+    const apiKey  = this._overrides.apiKey || process.env.VOXFORGE_KEY || '';
+    const model   = process.env.VOXFORGE_MODEL || 'voxforge-v1';
+    const resolvedVoice = voice || process.env.VOXFORGE_VOICE || 'narrator';
+    const rate    = this._overrides.rate || process.env.TTS_RATE || '+0%';
+
+    const headers = { 'Content-Type': 'application/json' };
+    if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`;
+
+    // Try OpenAI-compatible /v1/audio/speech first; fall back to /v1/tts
+    const endpoints = [
+      `${baseUrl}/v1/audio/speech`,
+      `${baseUrl}/v1/tts`,
+    ];
+
+    return withRetry(async () => {
+      for (const url of endpoints) {
+        try {
+          const isOpenAIPath = url.endsWith('/speech');
+          const body = isOpenAIPath
+            ? { model, input: text, voice: resolvedVoice }
+            : { text, voice: resolvedVoice, rate, model };
+          const audio = await httpPost(url, body, headers);
+          await fs.writeFile(outputPath, Buffer.isBuffer(audio) ? audio : Buffer.from(audio, 'binary'));
+          const stat = await fs.stat(outputPath);
+          if (stat.size > 500) return outputPath;
+        } catch (err) {
+          if (endpoints.indexOf(url) === endpoints.length - 1) throw err;
+          // try next endpoint
+        }
+      }
+      throw new Error('VoxForge: all endpoints failed');
+    }, { maxAttempts: 3, baseDelayMs: 3000, label: 'TTS(voxforge)' });
+  }
+
   async _customTTS({ text, voice, outputPath }) {
     const url = this._overrides.webhookUrl || process.env.CUSTOM_TTS_URL || process.env.TTS_WEBHOOK_URL;
     if (!url) throw new Error('CUSTOM_TTS_URL or TTS_WEBHOOK_URL not set for custom/webhook TTS provider');