@kolbo/mcp 1.91.3 → 1.92.0

package/README.md

@@ -264,7 +264,7 @@ Every generation tool also accepts an optional `project_id` arg that routes the
 | `blender_get_command_status` | Read bounded command status/result/error plus absolute `expires_at`; records and idempotency claims expire after 24 hours, and `awaiting_approval` means stop and wait for the user |
 
 **Premiere Pro & After Effects Bridge**
-Requires the Kolbo Studio panel open in Premiere Pro or After Effects with **AI agents** switched on in its header. Every edit is approved by the editor inside the panel; there is no raw ExtendScript tool.
+Requires the Kolbo Studio panel open in Premiere Pro or After Effects with **AI agents** switched on in its header. Every edit is approved by the editor inside the panel; scripts are shown in full before they run.
 
 | Tool | Description |
 |------|-------------|
@@ -275,6 +275,9 @@ Requires the Kolbo Studio panel open in Premiere Pro or After Effects with **AI
 | `adobe_place_on_timeline` | Import and place one Kolbo media item at the playhead of the work sequence / active comp (no time or track control in v1) |
 | `adobe_create_sequence` | Create and open a Premiere Pro sequence matching the open sequence's settings, no dialog (Premiere only) |
 | `adobe_import_captions` | Import a Kolbo-hosted SRT onto the active Premiere sequence (Premiere only) |
+| `adobe_edit_composition` | After Effects: one undo step of structured edits - comps, timed and trimmed Kolbo media, titles with stroke, solids, transforms, keyframes, audio fades, layer deletion |
+| `adobe_run_script` | Approval-gated ExtendScript for real motion graphics (shape layers, trim paths, text animators, effects, expressions, cameras); the editor reviews the exact code |
+| `adobe_capture_frame` | Render a comp/sequence frame to the Kolbo library so the agent can check its work |
 | `adobe_get_command_status` | Read command status/result/error; `awaiting_approval` means stop and wait for the editor |
 
 **Discovery & Account**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kolbo/mcp",
-  "version": "1.91.3",
+  "version": "1.92.0",
   "description": "Kolbo AI MCP Server - Generate images, videos, music, speech, and sound effects from Claude Code",
   "main": "src/index.js",
   "bin": {

package/skill/GENERATED.md

@@ -1,6 +1,6 @@
 # AUTO-GENERATED — do not edit
 
-This tree is mirrored from kolbo-code@c1a6a60, the single source of truth.
+This tree is mirrored from kolbo-code@972d2b4, the single source of truth.
 Canonical source: packages/opencode/skills/kolbo/
 Distribution: .github/workflows/sync-skill-to-plugin.yml
 

package/skill/SKILL.md

@@ -1,5 +1,5 @@
 ---
-version: 0.9.16
+version: 0.9.17
 name: kolbo
 description: |
   Generate, edit, analyze, and direct creative media through Kolbo AI: images,

package/skill/VERSION

@@ -1 +1 @@
-0.9.16
+0.9.17

package/skill/assets/filmmaking/shot-card.template.json

@@ -9,6 +9,9 @@
   "generation_mode": "reference-to-video",
   "control_density": "anchored",
   "duration_seconds": 8,
+  "shot_count": 1,
+  "continuous_take": true,
+  "post_voiceover": [],
   "aspect_ratio": "16:9",
   "active_assets": [
     {

package/skill/references/filmmaking/validation.md

@@ -2,6 +2,20 @@
 
 ## Pre-generation audit
 
+Read the current creative brief, including rejected concepts and scene-specific
+exceptions. Compare it to the final prompt and actual tool arguments, not the
+assistant's explanation. Run `scripts/filmmaking/lint_prompt.py` against the shot
+card for saved prompts. It checks Total duration/aspect/count, SHOT numbering,
+continuous-take conflicts and exact multilingual tags. Optional card fields:
+`shot_count`, `continuous_take`, dialogue items' `prompt_text` (exact text sent
+to the model, including requested transliteration), and `post_voiceover` (a list
+of exact narration strings excluded from generation). These checks do not prove
+camera semantics, humor, visual quality or model adherence; review those separately.
+
+Elements also rejects explicit Total declarations contradicting tool duration,
+aspect or shot flags before submission. Resolve the mismatch against the brief;
+do not strip declarations just to bypass validation. Free-form prompts remain supported.
+
 ### Story and edit
 
 - Does the shot have a necessary dramatic/editorial job?

package/skill/references/models/seedance.md

@@ -11,6 +11,10 @@ Load this file when the user wants a **Seedance 2 / Seedance 2.0** (ByteDance) v
 
 **Elements uses this same file.** `generate_elements` is not a second prompt language. Do not write `SCENE CONTEXT` / `OPTICS` / `ACTION` department packs for Elements or Seedance — those are filmmaking audit contracts, not the generation compile shape.
 
+## Creative direction takes precedence
+
+The current user brief overrides template defaults and illustrative examples. Keep the two-layer organization, but include only relevant locks. State concrete camera trajectory and visible action prominently; optics numbers, equipment names, repetition and word counts are not guarantees of fidelity. Preserve a continuous-shot exception even when other scenes are multishot. For one shot use `Single continuous shot`, `Total: Xs / 1 shot / AR`, one SHOT heading and `multi_shots: false`; for multiple shots use `Multishot ON` and matching counts. AR comes from the brief, never a copied example. Keep dialogue in the user's requested language or phonetic spelling; test pronunciation rather than claiming guaranteed support or impossibility. Narration reserved for post does not belong in the generation prompt.
+
 ## Universal Rules (apply to EVERY Seedance / Elements prompt)
 
 - **NO MUSIC BY DEFAULT (HARD):** Unless the user explicitly asks for music, every final Seedance prompt—including every Elements/reference-driven prompt—must explicitly say `No music. No musical score.` Keep requested dialogue, synchronized production sound, ambience, and SFX; "no music" does not mean "no audio." If the user explicitly requests music, describe that music instead and omit the no-music lock. Never invent background music from cinematic tone alone.
@@ -26,13 +30,13 @@ Load this file when the user wants a **Seedance 2 / Seedance 2.0** (ByteDance) v
   - A prompt with only shot body and no Total / Multishot header is a **failed turn** — rewrite before calling `generate_*`.
 - **MCP `duration` must match the Total line.** Pass `duration: X` (whole seconds) on `generate_video` / `generate_elements` / `generate_video_from_image` equal to the `Xs` in `Total: Xs / …`. Mismatch = wrong-length clip.
 - **Then the Locked Intro** — `[GLOBAL LOOK]` / `[CAST]` / `[LOCATION]` (+ LOCATION MAP / CONTINUITY / PHYSICS for multi-shot) — before any shot. A one-liner `same character throughout` is not a character lock.
-- **Order inside each shot**: Subject → Action → Camera → Constraints → (Audio/SFX if relevant). Do NOT restack GLOBAL LOOK style inside the shot.
-- **Prompt length**: simple single-idea pieces ~120–280 words. Locked-intro cinematic typically 400–900 words. Shorter than ~120 words = random output. The 10,000-char cap below always wins.
+- **Inside each shot:** make the camera trajectory, subject action and timing easy to find. Put a requested signature camera move in the heading. Do not restack GLOBAL LOOK style inside the shot.
+- **Prompt length**: simple single-idea pieces ~120–280 words. Locked-intro cinematic typically 400–900 words. These are examples, not minimum lengths. Do not pad. The selected model catalog cap wins; Seedance 2.5 uses its own adapter.
 - **Shot count is user-directed.** If the user asks for N shots, deliver exactly N in one prompt unless they ask to split.
-- **Always describe at least one camera movement per shot.**
+- **Describe the camera behavior requested for each shot.** Preserve intentional static shots; do not replace requested dynamic moves with static dialogue coverage.
 - **Tell Seedance what the camera is NOT doing** (e.g. `no cuts, no zoom, natural head movement`) — this is what locks POV.
-- **Final prompt is always English**, wrapped in a copy-ready code block. Detect intent in any language and reply in the user's language, but the prompt itself is English.
-- **HARD CAP: 10,000 characters TOTAL for the ENTIRE prompt** — measured as one single string including all shots, boilerplate, SFX lines, and the Total lines. It is per PROMPT, not per shot. **Never** split into multiple prompts, code blocks, or "part 1 / part 2" to evade the cap. Count the final prompt before output; if over, trim (cut adjectives, collapse boilerplate, shorten SFX lists, merge or drop shots) and re-count until it fits.
+- **Control prose defaults to English; exact dialogue and asset tags retain the user-requested language**, wrapped in a copy-ready code block. Reply in the user's language; preserve any explicit request for the prompt language too.
+- **HARD CAP: 10,000 characters TOTAL for the ENTIRE prompt** — measured as one single string including all shots, boilerplate, SFX lines, and the Total lines. It is per PROMPT, not per shot. **Never** split into multiple prompts, code blocks, or "part 1 / part 2" to evade the cap. Count the final prompt before output; if over, trim (cut adjectives, collapse boilerplate, shorten SFX lists, tighten redundant shot prose without dropping user-requested shots) and re-count until it fits.
 
 ## Locked Intro (DEFAULT for any multi-shot cinematic — including Elements)
 
@@ -138,7 +142,7 @@ Appearance locks WHO. Persona locks HOW THEY BEHAVE — without it Seedance rend
 ## Dialogue & expression
 
 - **Dialogue is PERFORMED by the model, never by a TTS tool.** Quoted lines in the prompt come back as synced speech with lip movement and room tone, together with the SFX you name in AUDIO. Scene dialogue therefore never routes through `generate_speech` or `generate_lipsync` — write the line in quotes inside its shot beat and let Seedance act it.
-- **Write dialogue in ENGLISH.** Seedance does not reliably perform other languages, and Hebrew in particular does not work — it comes back as accented gibberish or English-shaped mouth movement. Never offer a user "Hebrew dialogue directly". If the delivered film has to be Hebrew, the honest routes are: (a) keep the spoken lines English, or (b) stage the beat as expression + on-screen text, or (c) generate the scene clean and dub it afterwards as an explicit, separately-priced pass. Say which one you are doing.
+- **Preserve requested dialogue and its language.** If the user requests Hebrew in Latin letters, preserve that phonetic text as dialogue, not an English translation. Native pronunciation and lip-sync require actual output inspection. Do not promise success or claim the language is impossible without current evidence. Offer a separately authorized dubbing pass only when needed; keep narration reserved for post out of the prompt.
 - `list_models` reports `sound_generation_type: "none"` for Seedance 2 / 2.5 because there is no in-app sound toggle (`sound_baked_in: true`). That field does NOT mean the model is silent. Do not read it as a reason to add TTS.
 - For silent tension, deliver it as expression, not speech: `He does not speak. His expression clearly says: "…"`.
 
@@ -231,7 +235,7 @@ Use only the discrete steps. Not "23°" — use 18° or 29°.
 
 ### Camera placement
 
-Place CAMERA in the **3rd position** of each shot's core layers (Subject → Action → Camera → Style → Constraints). FOV gets ignored at the end, conflicts with identity at the front.
+Place a requested signature CAMERA trajectory prominently in the shot heading, then describe its timing with the subject action. GLOBAL LOOK owns shared lens / stock / grade. No fixed word order guarantees adherence.
 
 ### Pre-flight checklist (before output)
 

package/skill/references/models/seedance25.md

@@ -11,7 +11,7 @@ Load this file when the user wants a **Seedance 2.5** video (they said "2.5" / "
 
 **Audio:** Seedance 2.5 emits real synced audio. `list_models` shows `sound_generation_type: none` only because there is no in-app toggle (`sound_baked_in: true`) — it does NOT mean the model is silent, and it is never a reason to reach for TTS. Quoted dialogue is PERFORMED (synced voices, lip movement, room tone) alongside the SFX named in AUDIO, so scene dialogue never goes through `generate_speech` or `generate_lipsync`; write the lines in quotes inside their shot beats.
 
-**Dialogue language: English.** Other languages are not reliably performed, and Hebrew does not work — it returns accented gibberish or English-shaped mouth movement. Never offer a user "Hebrew dialogue directly". This restriction applies to rendered dialogue/prose only, never to binding identifiers: preserve an exact stored Hebrew Visual DNA or moodboard tag such as `@אביב` / `#ישראל` literally. See `models/seedance.md` for the three honest alternatives.
+**Dialogue language follows the user.** Preserve requested Hebrew or Hebrew-in-Latin transliteration; do not translate it into English or change the spoken content. Pronunciation and lip-sync must be inspected in the generated output, not guaranteed from the prompt. Keep post-production VO out of the generation prompt. Asset tags always retain their exact stored spelling, including `@אביב` / `#ישראל` literally.
 
 **Use the cheapest supported tier unless the user selected an output resolution.** Resolution is a credit MULTIPLIER, not a flat rate. Relative to 720p: 480p ×0.44, 1080p ×2.25. A 30s pass costs ~540cr at 480p against ~1230cr at 720p and ~2770cr at 1080p. When no output resolution was selected and 480p is the cheapest supported tier, block the film at 480p, get the user's sign-off on staging, performance and timing, then re-run only the approved cut at a higher delivery resolution if the user explicitly authorizes that resolution increase. Approval of the creative cut alone does not authorize a more expensive resolution. If no output resolution was selected, use the cheapest supported tier from the live catalog even for final work; pass it explicitly.
 
@@ -27,6 +27,8 @@ Load this file when the user wants a **Seedance 2.5** video (they said "2.5" / "
 
 ## Universal Rules (HARD — same as help widget OUTPUT CONTRACT)
 
+User-selected shot structure wins over examples. One continuous take uses `Single continuous shot`, `Total: Xs / 1 shot / AR`, one SHOT heading and `multi_shots: false`. Use Multishot ON only for multiple shots. Copy aspect, duration, dialogue and camera direction from the current scene brief. Expand craft blocks only when they resolve a real staging need; do not pad or introduce contradictory locks.
+
 - **First lines ALWAYS declare shot structure** (text-to-video / Elements / reference gen — NOT video-edit):
   1. `N connected cinematic shots, Xs total, AR, Multishot ON`
   2. `Total: Xs / N shots / AR`

package/skill/references/workflows/filmmaking.md

@@ -6,6 +6,10 @@ Operate as a filmmaking system, not merely a prompt writer. Preserve project tru
 
 ## Start here
 
+For a continuing production, read `.kolbo/creative-brief.md` before compiling or revising scenes. Keep it as a compact working table: stable scene ID, current world/action/tone, first-frame and camera trajectory/framing, shot count, duration/aspect, asset IDs and exact tags, spoken lines versus VO reserved for post, approval state, rejected concepts, and pending job IDs. Update only the dimensions changed by the user. Preserve the brief across compaction; do not put unapproved generations into `.kolbo/production.md`.
+
+User direction wins over template defaults and examples. A custom skill supplements this workflow; do not require its missing supporting files without explaining the gap, and never claim to have read them. Check the final prompt and tool arguments against the brief before dispatch. A request for active movement does not require running; bright lighting does not imply pastel colors or restrained action. Replace rejected worlds substantively. Preserve approved scenes and local single-shot exceptions.
+
 1. Identify the requested production stage and deliverable.
 2. Read only the reference files required by the routing table below.
 3. Preserve or establish the relevant production truth before writing a shot.
@@ -115,6 +119,8 @@ When a generation fails:
 5. Log the change and verdict.
 6. After repeated failures, redesign the shot: bake the state into an asset, add a staging/layout reference, reduce actions, split the shot, change the angle, or switch model/mode.
 
+Validate the revised approach on one representative shot before another batch, within existing authorization and budget; an explicit request for the whole batch wins. Do not silently split a user-requested continuous take, switch their selected model, or add paid tests. Distinguish defects observed in video/audio from hypotheses inferred from the prompt. Completion alone never verifies camera movement, cuts or performance.
+
 Do not keep polishing adjectives when the shot is physically or structurally overconstrained.
 
 ## Validate

package/skill/references/workflows/visual-dna.md

@@ -8,6 +8,10 @@ Visual DNA profiles capture the visual "identity" of a character, style, product
 
 ## Workflow
 
+### Creation failure recovery
+
+Create DNA through the available tool when the user requested it; do not default to asking for manual wizard work. A reference-preparation error **before submission** means this attempt did not create a profile. For an uncertain submission, reconcile with a personal/project-scoped list and inspect the matching profile before retrying. Existence alone does not establish that an errored call created it. Stop repeating an identical runtime error; report the exact failure and the verified scope, without inventing an auth outage or claiming reconnect will fix it. After success, check the returned ID, exact stored name, type and references; correct confirmed metadata errors in place rather than recreating. A headless wardrobe sheet for a recurring person remains character DNA.
+
 1. **Sheet first, then DNA.** For any production asset (character / location / prop), resolve the sheet **preset** (`list_presets` with `search`) and `generate_image` with that `preset_id` — custom instructions live on the preset. Then `create_visual_dna` with the sheet as `character_sheet_url` (max 4 extra images — if the user gives more, pick the 4 most representative **that share the same identity and vibe**; never pass 5+). Optionally video and audio. See **Purity** below before you generate those stills.
 2. **Types**: `character` (default), `style`, `product`, `scene`, `environment`.
 3. **Use** the profile by passing its `id` in `visual_dna_ids` in: `generate_image`, `generate_creative_director`, `generate_elements`, `generate_video_from_image`, `generate_video_from_video`, `generate_first_last_frame`.

package/skill/scripts/filmmaking/lint_prompt.py

@@ -10,8 +10,9 @@ from pathlib import Path
 from typing import Any
 
 
-TAG_RE = re.compile(r"@[A-Za-z][A-Za-z0-9_.:-]*(?:\s+\d+)?")
+TAG_RE = re.compile(r"@[\w][\w.:-]*(?:\s+\d+)?", re.UNICODE)
 SHOT_RE = re.compile(r"(?im)^\s*(?:SHOT|SEGMENT)\s+(\d+)\b")
+TOTAL_RE = re.compile(r"(?im)^\s*Total:\s*(\d+(?:\.\d+)?)s\s*/\s*(\d+)\s*shots?\s*/\s*(\d+:\d+)\s*$")
 RANGE_RE = re.compile(
     r"(?i)(\d+(?:\.\d+)?)\s*s\s*(?:-|–|—|to)\s*(\d+(?:\.\d+)?)\s*s"
 )
@@ -98,7 +99,7 @@ def check_adapter(
 
 def check_contradictions(prompt: str, report: Report) -> None:
     continuous = re.search(
-        r"(?i)\b(one|single)\s+(?:unbroken\s+)?continuous\s+take\b|\bno\s+cuts?\b",
+        r"(?i)\b(one|single)\s+(?:unbroken\s+)?continuous\s+(?:take|shot)\b|\bno\s+cuts?\b",
         prompt,
     )
     cuts = re.search(r"(?i)\b(hard|match|smash|jump|whip)\s+cut\b|\bhard\s+cuts\b", prompt)
@@ -144,8 +145,18 @@ def check_stale_language(prompt: str, report: Report) -> None:
 
 
 def check_tags(prompt: str, card: dict[str, Any] | None, report: Report) -> tuple[set[str], set[str]]:
-    found = {value.rstrip(".,;:!?") for value in TAG_RE.findall(prompt)}
     expected = expected_tags(card)
+    # Exact stored names may contain spaces, punctuation and non-Latin letters.
+    # Match those first, then scan the remainder for unregistered tags. Never
+    # normalize a canonical name, or accept @maya2 as a match for @maya.
+    remaining = prompt
+    found: set[str] = set()
+    for tag in sorted(expected, key=len, reverse=True):
+        pattern = re.escape(tag) + r"(?![\w:-])"
+        if re.search(pattern, remaining):
+            found.add(tag)
+            remaining = re.sub(pattern, "", remaining)
+    found.update(value.rstrip(".,;:!?") for value in TAG_RE.findall(remaining))
     for tag in sorted(expected - found):
         report.error("missing_active_asset", f"Shot-card asset is absent from prompt: {tag}")
     for tag in sorted(found - expected):
@@ -162,6 +173,40 @@ def check_tags(prompt: str, card: dict[str, Any] | None, report: Report) -> tupl
     return found, expected
 
 
+def check_contract(prompt: str, card: dict[str, Any] | None, report: Report) -> None:
+    """Check explicit structure, not subjective direction or rendered quality."""
+    totals = [(float(seconds), int(count), aspect) for seconds, count, aspect in TOTAL_RE.findall(prompt)]
+    if totals and any(total != totals[0] for total in totals):
+        report.error("conflicting_totals", "Opening and closing Total declarations disagree.")
+    shots = [int(value) for value in re.findall(r"(?im)^\s*SHOT\s+(\d+)\b", prompt)]
+    if shots and shots != list(range(1, len(shots) + 1)):
+        report.error("shot_sequence", "SHOT headings must be unique and sequential from 1.")
+    if totals and shots and totals[0][1] != len(shots):
+        report.error("shot_count_mismatch", "Total shot count differs from the SHOT headings.")
+    if not card:
+        return
+    for duration, count, aspect in totals:
+        if card.get("duration_seconds") is not None and duration != card["duration_seconds"]:
+            report.error("duration_mismatch", "Prompt Total duration differs from the shot card.")
+        if card.get("aspect_ratio") and aspect != card["aspect_ratio"]:
+            report.error("aspect_mismatch", "Prompt Total aspect differs from the shot card.")
+        if card.get("shot_count") is not None and count != card["shot_count"]:
+            report.error("brief_shot_count_mismatch", "Prompt Total shot count differs from the shot card.")
+    if card.get("shot_count") is not None and shots and len(shots) != card["shot_count"]:
+        report.error("brief_shot_count_mismatch", "SHOT headings differ from the shot card count.")
+    if card.get("continuous_take") is True:
+        if len(shots) > 1 or any(count != 1 for _, count, _ in totals) or re.search(r"(?i)\bMultishot\s+ON\b", prompt):
+            report.error("brief_continuous_take", "The brief requires one continuous take; prompt declares multiple shots.")
+    for item in card.get("dialogue", []):
+        if isinstance(item, dict):
+            text = item.get("prompt_text")
+            if isinstance(text, str) and text not in prompt:
+                report.error("missing_dialogue", "Exact prompt_text from the dialogue card is missing or rewritten.")
+    for text in card.get("post_voiceover", []):
+        if isinstance(text, str) and text and text in prompt:
+            report.error("post_voiceover_in_prompt", "Narration reserved for post-production appears in the generation prompt.")
+
+
 def check_timing(prompt: str, card: dict[str, Any] | None, report: Report) -> None:
     duration = card.get("duration_seconds") if card else None
     for start_text, end_text in RANGE_RE.findall(prompt):
@@ -220,6 +265,7 @@ def main() -> int:
     found, expected = check_tags(prompt, card, report)
     check_timing(prompt, card, report)
     check_dialogue_card(card, report)
+    check_contract(prompt, card, report)
 
     result = {
         "prompt": str(args.prompt.resolve()),

package/src/toolAnnotations.js

@@ -105,12 +105,15 @@ const OPEN_WORLD_WRITE = [
   'publish_html_artifact', 'create_review_share_link', 'blender_capture_viewport',
   // Adobe edits add bins, clips, sequences or caption tracks; none delete or overwrite.
   'adobe_import_media', 'adobe_place_on_timeline', 'adobe_create_sequence', 'adobe_import_captions',
+  'adobe_capture_frame',
 ];
 
 const OPEN_WORLD_DESTRUCTIVE = [
   'share_doc', 'revoke_review_share_link',
   'blender_apply_operations', 'blender_import_media', 'blender_render',
   'blender_undo', 'blender_file_operation', 'blender_execute_python',
+  // Can delete layers; approved once per batch in the Kolbo panel.
+  'adobe_edit_composition', 'adobe_run_script',
 ];
 
 const CONTRACT_GROUPS = [

package/src/tools/_shared.js

@@ -24,7 +24,10 @@ const fs = require('fs');
 const path = require('path');
 const net = require('net');
 const dns = require('dns').promises;
-const { Agent, fetch: undiciFetch } = require('undici');
+// Never load Bun's incomplete built-in undici shim. Node uses the installed
+// dispatcher below; Bun uses native fetch pinned to vetted IPs (its node:tls
+// compatibility transport can return empty peer certificates intermittently).
+const { Agent, fetch: undiciFetch } = require('undici/index.js');
 
 const MAX_FILE_BYTES = 500 * 1024 * 1024; // 500 MB — larger than visual_dna because
                                            // lipsync/v2v/transcription accept full
@@ -201,42 +204,73 @@ async function resolvePublicAddresses(hostname) {
   return rows;
 }
 
-function pinnedDispatcher(addresses) {
+function pinnedDispatcher(addresses) {
   let cursor = 0;
-  return new Agent({
-    connect: {
-      lookup(_hostname, options, callback) {
+  return new Agent({
+    connect: {
+      lookup(_hostname, options, callback) {
         if (options?.all) return callback(null, addresses);
         const row = addresses[cursor++ % addresses.length];
         return callback(null, row.address, row.family);
       },
     },
   });
-}
+}
+
+async function release(dispatcher) {
+  try { await dispatcher.close(); } catch (_) { /* Cleanup must not mask fetch errors. */ }
+}
+
+async function bunFetch(url, addresses, signal) {
+  let error;
+  for (const row of addresses) {
+    const pinned = new URL(url);
+    pinned.hostname = row.family === 6 ? `[${row.address}]` : row.address;
+    try {
+      return await fetch(pinned, {
+        redirect: 'manual', signal,
+        // Disable environment proxy routing: the connection must use the
+        // checked address, while HTTP routing and TLS verification use the
+        // original hostname. Never disable certificate verification.
+        proxy: '',
+        headers: { Host: url.host },
+        tls: url.protocol === 'https:' ? {
+          serverName: url.hostname.replace(/^\[|\]$/g, ''), rejectUnauthorized: true,
+        } : undefined,
+      });
+    } catch (err) {
+      error = err;
+      if (signal?.aborted) throw err;
+    }
+  }
+  throw error;
+}
 
 async function safeFetch(rawUrl, opts = {}) {
   let current = rawUrl;
   for (let i = 0; i <= MAX_REDIRECTS; i++) {
     const url = assertSafeUrl(current);
     const addresses = await resolvePublicAddresses(url.hostname);
-    const dispatcher = pinnedDispatcher(addresses);
+    const dispatcher = process.versions.bun ? null : pinnedDispatcher(addresses);
     let res;
     try {
-      res = await undiciFetch(current, { redirect: 'manual', signal: opts.signal, dispatcher });
+      res = process.versions.bun
+        ? await bunFetch(url, addresses, opts.signal)
+        : await undiciFetch(current, { redirect: 'manual', signal: opts.signal, dispatcher });
     } catch (err) {
-      await dispatcher.close().catch(() => {});
+      if (dispatcher) await release(dispatcher);
       throw err;
     }
     if (res.status >= 300 && res.status < 400 && res.headers.get('location')) {
       const next = new URL(res.headers.get('location'), current).toString();
       await res.body?.cancel().catch(() => {});
-      await dispatcher.close().catch(() => {});
+      if (dispatcher) await release(dispatcher);
       current = next;
       continue;
     }
     // close() waits for this response body to be consumed, so schedule it but
     // do not await it before returning the Response to the caller.
-    dispatcher.close().catch(() => {});
+    if (dispatcher) void release(dispatcher);
     return res;
   }
   throw new Error(`Too many redirects fetching ${rawUrl}`);

package/src/tools/adobe.js

@@ -31,6 +31,114 @@ const mediaUrl = z.string().url().max(4096).optional()
 const mediaKind = z.enum(['video', 'image', 'audio']).optional()
   .describe('Media kind. Inferred from the Kolbo record or file extension when omitted.');
 
+// ─── adobe_edit_composition operation schema (mirrors kolbo-api adobe/schemas.js) ───
+const seconds = (min = 0) => z.number().finite().min(min).max(3600);
+const color = () => z.array(z.number().finite().min(0).max(1)).length(3).describe('[r, g, b], each 0-1');
+const point = () => z.array(z.number().finite().min(-100000).max(100000)).length(2).describe('[x, y] in composition pixels; [0, 0] is top-left');
+const layerRef = z.union([z.number().int().min(1).max(10000), noControls(128)])
+  .describe('Layer name (exact) or 1-based index, 1 = top layer');
+// Titles may span lines; every other control character is refused.
+const TITLE_CONTROL = new RegExp('[\\x00-\\x09\\x0b\\x0c\\x0e-\\x1f]');
+const titleText = z.string().min(1).max(500).refine(
+  (value) => value.trim().length > 0 && !TITLE_CONTROL.test(value),
+  'Text must be 1-500 characters; newlines allowed, no other control characters.',
+);
+
+const compOperation = z.discriminatedUnion('op', [
+  z.object({
+    op: z.literal('comp.create'),
+    name: noControls(128),
+    width: z.number().int().min(16).max(8192).optional().describe('Default 1920'),
+    height: z.number().int().min(16).max(8192).optional().describe('Default 1080'),
+    frame_rate: z.number().finite().min(1).max(120).optional().describe('Default 30'),
+    duration_seconds: seconds(0.1),
+    background_color: color().optional(),
+  }).strict(),
+  z.object({
+    op: z.literal('comp.update'),
+    name: noControls(128).optional(),
+    duration_seconds: seconds(0.1).optional(),
+    background_color: color().optional(),
+  }).strict(),
+  z.object({
+    op: z.literal('layer.add_media'),
+    media_id: mediaId,
+    url: mediaUrl,
+    kind: mediaKind,
+    name: noControls(128).optional().describe('Layer name; defaults to the file name. Name layers you will animate later.'),
+    start_seconds: seconds().optional().describe('Where the layer starts on the comp timeline. Default 0.'),
+    trim_start_seconds: seconds().optional().describe('Seconds skipped at the head of the source clip. Default 0.'),
+    duration_seconds: seconds(0.04).optional().describe('Visible length. Default: rest of the source (stills: rest of the comp).'),
+    fit: z.enum(['cover', 'contain', 'none']).optional().describe('Scale to fill the frame (cover, default), fit inside it, or keep size.'),
+  }).strict(),
+  z.object({
+    op: z.literal('layer.add_text'),
+    text: titleText,
+    name: noControls(128).optional(),
+    start_seconds: seconds().optional(),
+    duration_seconds: seconds(0.04),
+    font: noControls(128).optional().describe('PostScript font name. Default "Arial-BoldMT".'),
+    font_size: z.number().finite().min(4).max(1000).optional().describe('Default 100'),
+    color: color().optional().describe('Default white'),
+    stroke_color: color().optional().describe('Outline colour. Default black when stroke_width is set.'),
+    stroke_width: z.number().finite().min(0).max(100).optional().describe('Outline in pixels. Use 2-6 whenever text sits over bright or busy footage.'),
+    position: point().optional().describe('Centre of the text block. Default: centre of the comp.'),
+  }).strict(),
+  z.object({
+    op: z.literal('layer.add_solid'),
+    color: color(),
+    name: noControls(128).optional(),
+    start_seconds: seconds().optional(),
+    duration_seconds: seconds(0.04).optional(),
+  }).strict(),
+  z.object({
+    op: z.literal('layer.update'),
+    layer: layerRef,
+    new_name: noControls(128).optional(),
+    start_seconds: seconds().optional(),
+    trim_start_seconds: seconds().optional(),
+    duration_seconds: seconds(0.04).optional(),
+    position: point().optional(),
+    scale: z.number().finite().min(0).max(10000).optional().describe('Percent, uniform'),
+    opacity: z.number().finite().min(0).max(100).optional(),
+    rotation: z.number().finite().min(-36000).max(36000).optional().describe('Degrees'),
+    audio_levels: z.number().finite().min(-96).max(24).optional().describe('dB'),
+    enabled: z.boolean().optional(),
+  }).strict(),
+  z.object({
+    op: z.literal('layer.animate'),
+    layer: layerRef,
+    property: z.enum(['opacity', 'scale', 'position', 'rotation', 'audio_levels'])
+      .describe('opacity 0-100, scale percent, rotation degrees, audio_levels dB, position [x, y]'),
+    keyframes: z.array(z.object({
+      time_seconds: seconds().describe('Comp time of this key'),
+      value: z.union([z.number().finite().min(-36000).max(36000), point()]),
+    }).strict()).min(1).max(50),
+    easing: z.enum(['ease', 'linear']).optional().describe('Default ease'),
+  }).strict(),
+  z.object({
+    op: z.literal('layer.delete'),
+    layer: layerRef,
+  }).strict(),
+]);
+const compOperations = z.array(compOperation).min(1).max(100)
+  .superRefine((ops, ctx) => {
+    ops.forEach((operation, opIndex) => {
+      if (operation.op !== 'layer.animate') return;
+      const wantsPoint = operation.property === 'position';
+      operation.keyframes.forEach((key, index) => {
+        if (Array.isArray(key.value) !== wantsPoint) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: [opIndex, 'keyframes', index, 'value'],
+            message: wantsPoint ? 'position keyframes need [x, y]' : `${operation.property} keyframes need a number`,
+          });
+        }
+      });
+    });
+  })
+  .refine((ops) => Buffer.byteLength(JSON.stringify(ops), 'utf8') <= 256 * 1024, 'Operations must be at most 256 KiB as JSON.');
+
 function text(value) {
   return { content: [{ type: 'text', text: JSON.stringify(value, null, 2) }] };
 }
@@ -162,6 +270,52 @@ function registerAdobeTools(server, client) {
     }
   );
 
+  server.tool(
+    'adobe_edit_composition',
+    'After Effects only. Apply a batch of structured edits to a composition as ONE undo step: create or update a comp, add Kolbo media (trimmed and timed), text titles and solids, change layer timing/transform/opacity/audio, animate with keyframes, or delete layers. Times are in seconds on the composition timeline. Layers are addressed by the exact name you gave them or by 1-based index (1 = top). New layers stack on top; solids go to the bottom. Operations run in order and stop at the first failure (earlier ones stay applied). The editor approves the whole batch once in the Kolbo panel. Read workflows/adobe.md before the first call; verify with adobe_get_timeline afterwards.',
+    {
+      session_id: sessionId,
+      operations: compOperations,
+      idempotency_key: idempotencyKey,
+    },
+    async (args) => {
+      for (const operation of args.operations) {
+        if (operation.op === 'layer.add_media') mediaSource(operation, 'adobe_edit_composition layer.add_media');
+      }
+      return command(client, 'comp.edit', args, { operations: args.operations });
+    }
+  );
+
+  server.tool(
+    'adobe_run_script',
+    'Run ExtendScript inside the connected After Effects (or Premiere Pro) for real motion graphics: shape layers, trim paths, text animators, effects, masks, expressions, cameras, precomps. `code` is a FUNCTION BODY: use log(...) for progress and `return` a JSON-serialisable result. In After Effects the whole script is one undo step. The editor sees the exact code in the Kolbo panel and must approve it. Scripts have full access to the project and the computer, so never read or write files, call system.callSystem, or touch the network unless the user explicitly asked. Read workflows/after-effects-motion.md before writing motion graphics, then verify with adobe_capture_frame.',
+    {
+      session_id: sessionId,
+      code: z.string().min(1).max(64 * 1024).refine(
+        (value) => value.trim().length > 0 && Buffer.byteLength(value, 'utf8') <= 64 * 1024,
+        'Script must be non-empty and at most 64 KiB as UTF-8.',
+      ),
+      purpose: noControls(500).describe('Plain-language reason shown to the editor next to the code.'),
+      idempotency_key: idempotencyKey,
+    },
+    async (args) => command(client, 'script.run', args, { code: args.code, purpose: args.purpose })
+  );
+
+  server.tool(
+    'adobe_capture_frame',
+    'Render one frame of the active After Effects composition (PNG) or Premiere Pro sequence (JPEG) and save it to the Kolbo media library. The result carries the image `url` - look at it to check your motion graphics or edit before telling the user it is done. The editor approves it in the Kolbo panel.',
+    {
+      session_id: sessionId,
+      time_seconds: z.number().finite().min(0).max(3600).optional().describe('Frame time. Default: current playhead / comp time.'),
+      project_id: z.string().min(1).max(128).regex(SAFE_ID).optional().describe('Kolbo project to file the capture in.'),
+      idempotency_key: idempotencyKey,
+    },
+    async (args) => command(client, 'frame.capture', args, {
+      ...(args.time_seconds !== undefined ? { time_seconds: args.time_seconds } : {}),
+      ...(args.project_id ? { project_id: args.project_id } : {}),
+    })
+  );
+
   server.tool(
     'adobe_get_command_status',
     'Read the state, expires_at and bounded result/error of one Adobe command owned by the caller. awaiting_approval is not a polling state: stop and ask the user to approve or deny it in the Kolbo panel.',

package/src/tools/generate.js

@@ -11,6 +11,7 @@ const { ownedUrl } = require('./owned-url');
 const { UI, uiResult, canonicalModelId, assertModelSupportsType, modelInfo, voiceInfo, resolveCatalogAspectRatio } = require('../apps');
 const { modelTypeForEditOperation, assertExecutableEditModel } = require('./editModelCatalog');
 const { withLocalRehost } = require('./local-rehost');
+const { validateVideoPrompt } = require('./video-prompt');
 
 // ─── Cinematic Dimensions schema (shared by generate_image + generate_image_edit) ───
 // Kolbo's "Cinema mode": eight independent photographic dimensions, each an OPTIONAL
@@ -1454,8 +1455,10 @@ function registerGenerateTools(server, client, options = {}) {
       session_id: sessionIdField
     },
     async ({ prompt, model, reference_images, reference_videos, reference_audio_urls, audio_url, files, duration, aspect_ratio, motion, preset_id, enhance_prompt = false, visual_dna_ids, resolution, sound_enabled, keyframes, multi_shots, multi_shot_count, session_name, project_id, session_id }) => {
+      validateVideoPrompt({ prompt, duration, aspect_ratio, multi_shots, multi_shot_count });
       model = await canonicalModelId(client, model, 'elements'); // lenient id resolution ("z-image" → "z-image/turbo")
       aspect_ratio = await resolveCatalogAspectRatio(client, model, aspect_ratio, 'elements');
+      validateVideoPrompt({ prompt, duration, aspect_ratio, multi_shots, multi_shot_count });
       if (!prompt) throw new Error('prompt is required');
 
       // Elements is the one tool that takes all three modalities, and either a

package/src/tools/video-prompt.js

@@ -0,0 +1,20 @@
+// Validate only explicit, machine-readable declarations. Never infer creative
+// intent from adjectives, require a template, or rewrite a user's prompt.
+function validateVideoPrompt({ prompt, duration, aspect_ratio, multi_shots, multi_shot_count }) {
+  const totals = [...prompt.matchAll(/^\s*Total:\s*(\d+(?:\.\d+)?)s\s*\/\s*(\d+)\s*shots?\s*\/\s*(\d+:\d+)\s*$/gim)]
+    .map((m) => ({ duration: Number(m[1]), count: Number(m[2]), aspect: m[3] }));
+  if (!totals.length) return; // Existing free-form clients remain supported.
+  const total = totals[0];
+  const errors = [];
+  if (totals.some((t) => t.duration !== total.duration || t.count !== total.count || t.aspect !== total.aspect)) errors.push('Total declarations disagree');
+  if (duration != null && duration !== total.duration) errors.push('duration differs from prompt Total');
+  if (/^\d+:\d+$/.test(aspect_ratio || '') && aspect_ratio !== total.aspect) errors.push('aspect_ratio differs from prompt Total');
+  if (multi_shots === false && total.count > 1) errors.push('multi_shots=false conflicts with multiple declared shots');
+  if (multi_shots === true && total.count === 1) errors.push('multi_shots=true conflicts with one declared shot');
+  if (multi_shot_count != null && multi_shot_count !== total.count) errors.push('multi_shot_count differs from prompt Total');
+  const shots = [...prompt.matchAll(/^\s*SHOT\s+(\d+)\b/gim)].map((m) => Number(m[1]));
+  if (shots.length && (shots.length !== total.count || shots.some((n, i) => n !== i + 1))) errors.push('SHOT headings disagree with declared count or order');
+  if (errors.length) throw new Error(`Video prompt conflict before submission: ${errors.join('; ')}. Reconcile with the user's approved brief; no generation was submitted.`);
+}
+
+module.exports = { validateVideoPrompt };

package/src/tools/visual_dna.js

@@ -54,11 +54,13 @@ function registerVisualDnaTools(server, client, options = {}) {
       }
 
       // Resolve all sources to buffers in parallel.
-      const [imageFiles, videoFile, audioFile] = await Promise.all([
+      const [imageFiles, videoFile, audioFile] = await Promise.all([
         Promise.all(imageList.map(src => resolveToBuffer(src, 'image', options))),
         video ? resolveToBuffer(video, 'video', options) : Promise.resolve(null),
         audio ? resolveToBuffer(audio, 'audio', options) : Promise.resolve(null)
-      ]);
+      ]).catch((cause) => {
+        throw new Error(`Visual DNA reference preparation failed before submission; this attempt did not create a profile. ${cause.message}`, { cause });
+      });
 
       const form = new FormData();
       form.append('name', name);