@pixeldojo/mcp 0.8.0 → 0.9.1

package/dist/index.cjs

@@ -95,7 +95,7 @@ function pollResultToSkillResult(result, successText) {
   }
   return {
     kind: "handoff",
-    text: `Job ${result.jobId} is still running after the 30s sync window. Use pixeldojo:status with this jobId to check completion, or follow ${result.statusUrl}.`,
+    text: `Job ${result.jobId} is still running after the 30s sync window. Use pixeldojo_status with this jobId to check completion, or follow ${result.statusUrl}.`,
     jobId: result.jobId,
     statusUrl: result.statusUrl
   };
@@ -188,7 +188,8 @@ var init_upload_helpers = __esm({
 function getFieldConstraints(apiId, client) {
   const cached = schemaCache.get(apiId);
   if (cached) return cached;
-  const pending = client.getModelSchema(apiId).then(
+  if (typeof client?.getModelSchema !== "function") return Promise.resolve(null);
+  const pending = Promise.resolve().then(() => client.getModelSchema(apiId)).then(
     (res) => res.schema?.properties ?? {}
   ).catch(() => {
     schemaCache.delete(apiId);
@@ -232,6 +233,46 @@ async function snapAspectRatio(apiId, requested, client, opts = {}) {
   if (!field.enum || field.enum.length === 0) return requested;
   return nearestAspectFromEnum(requested, field.enum);
 }
+async function resolveReferenceField(apiId, client) {
+  const props = await getFieldConstraints(apiId, client);
+  if (props === null) return void 0;
+  for (const name of REFERENCE_FIELD_PRIORITY) {
+    const field = props[name];
+    if (field) return { name, isArray: field.type === "array" };
+  }
+  return null;
+}
+function resolutionHeight(value) {
+  const v = value.trim().toLowerCase();
+  if (v === "4k") return 2160;
+  const n = Number.parseInt(v, 10);
+  return Number.isFinite(n) ? n : null;
+}
+async function snapResolution(apiId, requested, client, opts = {}) {
+  if (!requested) return void 0;
+  const props = await getFieldConstraints(apiId, client);
+  if (props === null) {
+    return opts.onUnknown === "omit" ? void 0 : requested;
+  }
+  const field = props.resolution;
+  if (!field) return void 0;
+  if (!field.enum || field.enum.length === 0) return requested;
+  if (field.enum.includes(requested)) return requested;
+  const target = resolutionHeight(requested);
+  if (target === null) return requested;
+  let best = requested;
+  let bestDiff = Infinity;
+  for (const candidate of field.enum) {
+    const h = resolutionHeight(candidate);
+    if (h === null) continue;
+    const diff = Math.abs(h - target);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      best = candidate;
+    }
+  }
+  return best;
+}
 async function snapDuration(apiId, requested, client, opts = {}) {
   if (requested === void 0) return void 0;
   const props = await getFieldConstraints(apiId, client);
@@ -256,13 +297,49 @@ async function snapDuration(apiId, requested, client, opts = {}) {
   }
   return requested;
 }
-var schemaCache;
+async function resolveImageRefs(apiId, urls, client) {
+  if (urls.length === 0) return null;
+  const props = await getFieldConstraints(apiId, client);
+  if (props === null) return null;
+  const key = REF_KEYS.find((k) => props[k] !== void 0);
+  if (!key) return null;
+  const field = props[key];
+  if (field.type === "array") {
+    const cap = typeof field.maxItems === "number" ? field.maxItems : urls.length;
+    const kept = urls.slice(0, Math.max(1, cap));
+    return { key, value: kept, dropped: urls.length - kept.length };
+  }
+  return { key, value: urls[0], dropped: urls.length - 1 };
+}
+var schemaCache, REFERENCE_FIELD_PRIORITY, REF_KEYS;
 var init_schema_snap = __esm({
   "src/skills/schema-snap.ts"() {
     schemaCache = /* @__PURE__ */ new Map();
+    REFERENCE_FIELD_PRIORITY = [
+      "image_url",
+      "start_image_url",
+      "input_image",
+      "image",
+      "reference_images",
+      "reference_urls",
+      "reference_image_urls",
+      "image_urls",
+      "image_input",
+      "images"
+    ];
+    REF_KEYS = [
+      "image_urls",
+      "images",
+      "image_input",
+      "reference_images",
+      "reference_urls",
+      "image_url",
+      "input_image",
+      "image"
+    ];
   }
 });
-function buildPayload(apiId, input) {
+function buildPayload(apiId, input, refField, referenceUrls = []) {
   const body = { prompt: input.prompt };
   if (input.aspect_ratio) body.aspect_ratio = input.aspect_ratio;
   if (input.preset) body.preset = input.preset;
@@ -280,8 +357,16 @@ function buildPayload(apiId, input) {
       }
       break;
     default:
-      if (input.image_url) body.image_url = input.image_url;
+      if (input.image_url) {
+        const refs = referenceUrls.length > 0 ? referenceUrls : [input.image_url];
+        if (refField) {
+          body[refField.name] = refField.isArray ? refs : refs[0];
+        } else {
+          body.image_url = refs[0];
+        }
+      }
       if (input.duration !== void 0) body.duration = input.duration;
+      if (input.resolution) body.resolution = input.resolution;
       break;
   }
   return body;
@@ -289,39 +374,51 @@ function buildPayload(apiId, input) {
 async function run(input, ctx) {
   const apiId = input.model ?? DEFAULT_MODEL;
   let resolved = input;
-  if (!input.image_url && input.image_path) {
-    try {
-      const uploadedUrl = await uploadLocalFile(input.image_path, ctx.client);
-      resolved = { ...input, image_url: uploadedUrl };
-    } catch (err) {
-      if (err instanceof SkillUploadError) {
-        return { kind: "text", text: `pixeldojo:generate (upload): ${err.userMessage}` };
-      }
-      throw err;
+  let referenceUrls = [];
+  try {
+    const singleUrl = input.image_url ?? (input.image_path ? await uploadLocalFile(input.image_path, ctx.client) : void 0);
+    const manyUrls = [...input.image_urls ?? []];
+    for (const p of input.image_paths ?? []) {
+      manyUrls.push(await uploadLocalFile(p, ctx.client));
+    }
+    referenceUrls = [...singleUrl ? [singleUrl] : [], ...manyUrls].filter(
+      (u, i, all) => all.indexOf(u) === i
+    );
+    if (referenceUrls[0] && referenceUrls[0] !== input.image_url) {
+      resolved = { ...input, image_url: referenceUrls[0] };
+    }
+  } catch (err) {
+    if (err instanceof SkillUploadError) {
+      return { kind: "text", text: `pixeldojo_generate (upload): ${err.userMessage}` };
     }
+    throw err;
   }
   if (apiId === "grok-video-extend") {
     if (!resolved.image_url) {
       return {
         kind: "text",
-        text: 'pixeldojo:generate with model="grok-video-extend" requires image_url (the source video URL to extend, or image_path for a local file).'
+        text: 'pixeldojo_generate with model="grok-video-extend" requires image_url (the source video URL to extend, or image_path for a local file).'
       };
     }
     if (resolved.duration === void 0) {
       return {
         kind: "text",
-        text: 'pixeldojo:generate with model="grok-video-extend" requires duration (extension length in seconds).'
+        text: 'pixeldojo_generate with model="grok-video-extend" requires duration (extension length in seconds).'
       };
     }
   }
+  let refField;
   if (!VIDEO_INPUT_MODELS.has(apiId)) {
-    const [aspect_ratio, duration] = await Promise.all([
+    const [aspect_ratio, duration, resolution, ref] = await Promise.all([
       snapAspectRatio(apiId, resolved.aspect_ratio, ctx.client),
-      snapDuration(apiId, resolved.duration, ctx.client)
+      snapDuration(apiId, resolved.duration, ctx.client),
+      snapResolution(apiId, resolved.resolution, ctx.client),
+      resolved.image_url ? resolveReferenceField(apiId, ctx.client) : Promise.resolve(void 0)
     ]);
-    resolved = { ...resolved, aspect_ratio, duration };
+    resolved = { ...resolved, aspect_ratio, duration, resolution };
+    refField = ref;
   }
-  const body = buildPayload(apiId, resolved);
+  const body = buildPayload(apiId, resolved, refField, referenceUrls);
   const submitted = await ctx.client.run(apiId, body);
   const result = await pollJobUntilDoneOrHandoff(
     submitted.jobId,
@@ -354,9 +451,18 @@ var init_generate = __esm({
       ),
       aspect_ratio: zod.z.string().optional().describe('Aspect ratio supported by the chosen model (e.g. "1:1", "16:9", "9:16").'),
       duration: zod.z.number().int().positive().optional().describe("Video duration in seconds, when applicable."),
+      resolution: zod.z.string().optional().describe(
+        'Output resolution when the model supports it (e.g. "480p", "720p", "1080p", "4k"). Lower tiers cost fewer credits. Omit to use the model default.'
+      ),
       image_url: zod.z.string().url().optional().describe("Reference image URL for image-to-image / image-to-video tools."),
       image_path: zod.z.string().min(1).optional().describe(
         "Absolute local file path to a reference image/video. The skill uploads it to PixelDojo first (24h temp storage) and then dispatches. Prefer this over image_url when the user has the file on disk."
+      ),
+      image_urls: zod.z.array(zod.z.string().url()).optional().describe(
+        "Multiple reference image URLs, for models that accept a reference set (character + wardrobe + location, for example). Models that take only one reference use the first and the rest are ignored."
+      ),
+      image_paths: zod.z.array(zod.z.string().min(1)).optional().describe(
+        "Multiple absolute local file paths. Each is uploaded to PixelDojo (24h temp storage) and used as a reference, same rules as image_urls."
       )
     });
     DEFAULT_MODEL = "google-nano-banana";
@@ -375,7 +481,21 @@ var init_generate = __esm({
         },
         aspect_ratio: { type: "string" },
         duration: { type: "integer" },
+        resolution: {
+          type: "string",
+          description: 'Output resolution when supported (e.g. "480p", "720p", "1080p", "4k"). Lower tiers cost fewer credits.'
+        },
         image_url: { type: "string", format: "uri" },
+        image_urls: {
+          type: "array",
+          items: { type: "string", format: "uri" },
+          description: "Multiple reference image URLs for models that accept a reference set. Single-reference models use the first."
+        },
+        image_paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "Multiple absolute local file paths, each uploaded to 24h temp storage and used as a reference."
+        },
         image_path: {
           type: "string",
           description: "Absolute local file path. The skill uploads it to PixelDojo (24h temp storage) and uses the resulting URL as the reference image. Prefer this over image_url when the user has a local file."
@@ -384,7 +504,7 @@ var init_generate = __esm({
       required: ["prompt"]
     };
     generateSkill = {
-      name: "pixeldojo:generate",
+      name: "pixeldojo_generate",
       description: "Generate any image or video from a prompt. Auto-routes to a sensible default model; pass `model` to pick a specific apiId from the catalog. For reference-image / image-to-video flows: pass `image_url` if you already have a URL, or `image_path` (absolute local path) and the skill uploads it to 24h temp storage automatically.",
       inputZod: InputSchema,
       inputJsonSchema: InputJsonSchema,
@@ -411,12 +531,21 @@ function buildPayload2(apiId, input) {
         ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
       };
     case "flux-edit":
-    case "xai-image-edit":
+      return {
+        prompt: input.prompt,
+        input_image_1: urls[0],
+        ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
+      };
     case "gpt-image-2-edit":
+      return {
+        prompt: input.prompt,
+        image_urls: urls.slice(0, 8),
+        ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
+      };
+    case "xai-image-edit":
       return {
         prompt: input.prompt,
         image_url: urls[0],
-        ...urls.length > 1 ? { image_urls: urls } : {},
         ...input.aspect_ratio ? { aspect_ratio: input.aspect_ratio } : {}
       };
     case "google-nano-banana":
@@ -432,6 +561,19 @@ function buildPayload2(apiId, input) {
       };
   }
 }
+async function buildBody(apiId, input, ctx) {
+  const urls = input.image_urls && input.image_urls.length > 0 ? input.image_urls : input.image_url ? [input.image_url] : [];
+  const refs = await resolveImageRefs(apiId, urls, ctx.client);
+  if (!refs) return { body: buildPayload2(apiId, input), dropped: 0 };
+  const fallback = buildPayload2(apiId, input);
+  const body = { ...fallback };
+  for (const key of ["image_url", "image_urls", "images", "image_input", "input_image_1"]) {
+    if (key !== refs.key) delete body[key];
+  }
+  body.prompt = input.prompt;
+  body[refs.key] = refs.value;
+  return { body, dropped: refs.dropped };
+}
 async function run2(input, ctx) {
   let resolved = input;
   try {
@@ -447,14 +589,14 @@ async function run2(input, ctx) {
     }
   } catch (err) {
     if (err instanceof SkillUploadError) {
-      return { kind: "text", text: `pixeldojo:edit (upload): ${err.userMessage}` };
+      return { kind: "text", text: `pixeldojo_edit (upload): ${err.userMessage}` };
     }
     throw err;
   }
   if (!resolved.image_url && (!resolved.image_urls || resolved.image_urls.length === 0)) {
     return {
       kind: "text",
-      text: "pixeldojo:edit requires at least one reference image. Pass image_url / image_urls (hosted URL) or image_path / image_paths (local file)."
+      text: "pixeldojo_edit requires at least one reference image. Pass image_url / image_urls (hosted URL) or image_path / image_paths (local file)."
     };
   }
   const apiId = resolved.model ?? DEFAULT_MODEL2;
@@ -462,7 +604,8 @@ async function run2(input, ctx) {
     ...resolved,
     aspect_ratio: await snapAspectRatio(apiId, resolved.aspect_ratio, ctx.client)
   };
-  const body = buildPayload2(apiId, resolved);
+  const { body, dropped } = await buildBody(apiId, resolved, ctx);
+  const droppedNote = dropped > 0 ? ` (${dropped} reference${dropped === 1 ? "" : "s"} dropped \u2014 ${apiId} accepts fewer)` : "";
   const submitted = await ctx.client.run(apiId, body);
   const result = await pollJobUntilDoneOrHandoff(
     submitted.jobId,
@@ -475,7 +618,7 @@ async function run2(input, ctx) {
   );
   return pollResultToSkillResult(
     result,
-    (urls) => urls.length === 0 ? `Edit job ${submitted.jobId} completed but returned no assets.` : urls.length === 1 ? `Edit complete. Asset: ${urls[0]}` : `Edit produced ${urls.length} assets. URLs: ${urls.join(", ")}`
+    (urls) => urls.length === 0 ? `Edit job ${submitted.jobId} completed but returned no assets.` : urls.length === 1 ? `Edit complete${droppedNote}. Asset: ${urls[0]}` : `Edit produced ${urls.length} assets${droppedNote}. URLs: ${urls.join(", ")}`
   );
 }
 var DEFAULT_MODEL2, ALLOWED_MODELS, InputSchema2, InputJsonSchema2, editSkill;
@@ -547,7 +690,7 @@ var init_edit = __esm({
       required: ["prompt"]
     };
     editSkill = {
-      name: "pixeldojo:edit",
+      name: "pixeldojo_edit",
       description: "Edit an existing image with a text instruction. Defaults to wan-2.7-image-edit; pass `model` to pick another edit-capable apiId. Supports up to 9 reference images for multi-image composition. For reference images: pass image_url(s) for hosted URLs or image_path(s) for absolute local file paths (skill uploads to 24h temp storage automatically).",
       inputZod: InputSchema2,
       inputJsonSchema: InputJsonSchema2,
@@ -562,14 +705,14 @@ async function run3(input, ctx) {
   if (!ALLOWED.includes(requested)) {
     return {
       kind: "text",
-      text: `Unknown model "${requested}" for pixeldojo:character. Allowed: ${ALLOWED.join(", ")}.`
+      text: `Unknown model "${requested}" for pixeldojo_character. Allowed: ${ALLOWED.join(", ")}.`
     };
   }
   const apiId = requested;
   if (REQUIRES_REFERENCE.has(apiId) && !input.reference_image_url) {
     return {
       kind: "text",
-      text: `pixeldojo:character with model="${apiId}" requires reference_image_url (the source image of the character to edit). For generation from a prompt alone, use model="${DEFAULT_MODEL3}".`
+      text: `pixeldojo_character with model="${apiId}" requires reference_image_url (the source image of the character to edit). For generation from a prompt alone, use model="${DEFAULT_MODEL3}".`
     };
   }
   const body = { prompt: input.prompt };
@@ -631,7 +774,7 @@ var init_character = __esm({
       required: ["prompt"]
     };
     characterSkill = {
-      name: "pixeldojo:character",
+      name: "pixeldojo_character",
       description: "Generate or edit consistent characters across shots. Pass a reference_image_url for identity locking (seedream-5 by default).",
       inputZod: InputSchema3,
       inputJsonSchema: InputJsonSchema3,
@@ -646,7 +789,7 @@ async function run4(input, ctx) {
   if (!ALLOWED2.includes(requested)) {
     return {
       kind: "text",
-      text: `Unknown model "${requested}" for pixeldojo:storyboard. Allowed: ${ALLOWED2.join(", ")}.`
+      text: `Unknown model "${requested}" for pixeldojo_storyboard. Allowed: ${ALLOWED2.join(", ")}.`
     };
   }
   const apiId = requested;
@@ -709,7 +852,7 @@ var init_storyboard = __esm({
       required: ["brief"]
     };
     storyboardSkill = {
-      name: "pixeldojo:storyboard",
+      name: "pixeldojo_storyboard",
       description: "Generate a video storyboard preview from a single brief. v1: single-shot preview; multi-shot orchestration coming.",
       inputZod: InputSchema4,
       inputJsonSchema: InputJsonSchema4,
@@ -724,7 +867,7 @@ async function run5(input, ctx) {
   if (!ALLOWED3.includes(requested)) {
     return {
       kind: "text",
-      text: `Unknown model "${requested}" for pixeldojo:upscale. Allowed: ${ALLOWED3.join(", ")}.`
+      text: `Unknown model "${requested}" for pixeldojo_upscale. Allowed: ${ALLOWED3.join(", ")}.`
     };
   }
   const apiId = requested;
@@ -786,7 +929,7 @@ var init_upscale = __esm({
       required: ["image_url"]
     };
     upscaleSkill = {
-      name: "pixeldojo:upscale",
+      name: "pixeldojo_upscale",
       description: "Enhance an image. Magnific (default) supports configurable scale_factor and creativity; face-enhance for portraits.",
       inputZod: InputSchema5,
       inputJsonSchema: InputJsonSchema5,
@@ -864,14 +1007,14 @@ var InputSchema6, InputJsonSchema6, STUCK_HINT_MS, ABANDON_HINT_MS, statusSkill;
 var init_status = __esm({
   "src/skills/status.ts"() {
     InputSchema6 = zod.z.object({
-      jobId: zod.z.string().min(1).max(200).describe("Job id returned from a prior pixeldojo:* skill handoff.")
+      jobId: zod.z.string().min(1).max(200).describe("Job id returned from a prior pixeldojo_* skill handoff.")
     });
     InputJsonSchema6 = {
       type: "object",
       properties: {
         jobId: {
           type: "string",
-          description: "Job id returned from a prior pixeldojo:* skill handoff."
+          description: "Job id returned from a prior pixeldojo_* skill handoff."
         }
       },
       required: ["jobId"]
@@ -879,7 +1022,7 @@ var init_status = __esm({
     STUCK_HINT_MS = 5 * 60 * 1e3;
     ABANDON_HINT_MS = 12 * 60 * 1e3;
     statusSkill = {
-      name: "pixeldojo:status",
+      name: "pixeldojo_status",
       description: "Check the status of a long-running job after a 30s sync handoff. Returns assets when ready, failure reason if failed, or current state if still running.",
       inputZod: InputSchema6,
       inputJsonSchema: InputJsonSchema6,
@@ -924,8 +1067,8 @@ var init_from_url = __esm({
       required: ["url"]
     };
     fromUrlSkill = {
-      name: "pixeldojo:from_url",
-      description: "Extract product info (name, description, images) from any product page URL. Use this as the first step before pixeldojo:campaign / :ad / :lookbook so the agent has structured product data instead of a free-text description.",
+      name: "pixeldojo_from_url",
+      description: "Extract product info (name, description, images) from any product page URL. Use this as the first step before pixeldojo_campaign / :ad / :lookbook so the agent has structured product data instead of a free-text description.",
       inputZod: InputSchema7,
       inputJsonSchema: InputJsonSchema7,
       // No model dispatch — this skill calls a server-side scrape, not a generation.
@@ -935,7 +1078,259 @@ var init_from_url = __esm({
     };
   }
 });
+async function filmApi(ctx, method, path, body) {
+  const res = await fetch(`${ctx.baseUrl}${path}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${ctx.apiKey}`,
+      "Content-Type": "application/json",
+      "x-pixeldojo-source": `mcp/${ctx.mcpVersion}`,
+      "x-pixeldojo-skill": "film"
+    },
+    ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+  });
+  const data = await res.json().catch(() => ({}));
+  return { status: res.status, data };
+}
+function progressLine(f) {
+  const all = shots(f);
+  const frames = all.filter((sh) => ["frame-ready", "approved", "clip-generating", "clip-ready"].includes(sh.status) || sh.frameUrl).length;
+  const clips = all.filter((sh) => sh.status === "clip-ready").length;
+  const rendering = all.filter((sh) => sh.status === "clip-generating").length;
+  return `frames ${frames}/${all.length}, clips ${clips}/${all.length}${rendering > 0 ? ` (${rendering} rendering)` : ""}`;
+}
+async function plan(input, ctx) {
+  if (!input.idea?.trim() && !input.script?.trim()) {
+    return { kind: "text", text: "Provide an `idea` (we write the script, free) or a full `script` to plan a film." };
+  }
+  const created = await filmApi(ctx, "POST", "/api/films", {
+    aspect: input.aspect,
+    look: input.look,
+    lengthTarget: input.length,
+    assetIds: []
+  });
+  if (!created.data.film) return { kind: "text", text: `Could not create the film: ${created.data.error ?? created.status}` };
+  const id = created.data.film.id;
+  let script = input.script?.trim() ?? "";
+  if (!script) {
+    const wrote = await filmApi(ctx, "POST", `/api/films/${id}/script`, { idea: input.idea.trim() });
+    script = wrote.data.film?.script ?? "";
+    if (!script) return { kind: "text", text: `Script writing failed: ${wrote.data.error ?? wrote.status}` };
+  }
+  const planned = await filmApi(ctx, "POST", `/api/films/${id}/plan`, { script });
+  const film = planned.data.film;
+  if (!film) return { kind: "text", text: `Shot planning failed: ${planned.data.error ?? planned.status}` };
+  const total = shots(film).length;
+  const sceneLines = film.scenes.map((s, i) => `  Scene ${i + 1} "${s.title}"${s.location ? ` [${s.location}]` : ""}: ${s.shots.length} shots`);
+  return {
+    kind: "text",
+    text: [
+      `Planned "${film.title}" (film_id: ${film.id}) \u2014 ${film.scenes.length} scenes, ${total} shots, ${input.look}, ${input.aspect}.`,
+      ...sceneLines,
+      "",
+      `Nothing has been charged yet. Producing renders every shot (roughly 20-25 credits per shot at default engines, charged as each renders) plus a few credits for the soundtrack.`,
+      `Review or edit at ${ctx.baseUrl}/film-studio/${film.id} \u2014 or call pixeldojo_film with {"film_id": "${film.id}", "action": "produce"} to start production.`
+    ].join("\n")
+  };
+}
+async function produce(filmId, ctx) {
+  const { data } = await filmApi(ctx, "GET", `/api/films/${filmId}`);
+  if (!data.film) return { kind: "text", text: `Film not found: ${data.error ?? filmId}` };
+  const pending = shots(data.film).filter((sh) => sh.status === "idle" || sh.status === "failed" && !sh.frameUrl);
+  let fired = 0;
+  for (const sh of pending.slice(0, 6)) {
+    const r = await filmApi(ctx, "POST", `/api/films/${filmId}/shots/${sh.id}/generate`, { kind: "frame" });
+    if (r.status === 200) fired += 1;
+  }
+  return {
+    kind: "text",
+    text: `Production started on "${data.film.title}": ${fired} frame(s) dispatched (each is a normal frame charge; the server's Frame check reviews every one). Poll pixeldojo_film with {"film_id": "${filmId}", "action": "status"} every ~30 seconds \u2014 each poll advances the pipeline.`
+  };
+}
+function buildScorePlanBody(film) {
+  const scenes = film.scenes.filter((s) => s.shots.length > 0);
+  const sections = scenes.flatMap((scene, i) => {
+    const runtime = Math.max(3e3, scene.shots.reduce((n, sh) => n + (sh.durationSec || 0), 0) * 1e3);
+    const styles = i === 0 ? ARC.opening : i === scenes.length - 1 ? ARC.finale : ARC.middle;
+    const parts = Math.max(1, Math.ceil(runtime / 12e4));
+    const partMs = Math.round(runtime / parts);
+    return Array.from({ length: parts }, (_, part) => ({
+      section_name: parts > 1 ? `${scene.title} (part ${part + 1})` : scene.title,
+      positive_local_styles: styles,
+      negative_local_styles: [],
+      duration_ms: part === parts - 1 ? runtime - partMs * (parts - 1) : partMs,
+      lines: []
+    }));
+  });
+  return {
+    composition_plan: {
+      positive_global_styles: (LOOK_MUSIC[film.look] ?? LOOK_MUSIC["live-action"]).split(", "),
+      negative_global_styles: ["vocals", "singing", "lyrics"],
+      sections
+    },
+    respect_sections_durations: true,
+    output_format: "mp3_standard"
+  };
+}
+function buildFlatMusicBody(film, all) {
+  const runtimeSec = all.reduce((n, sh) => n + (sh.durationSec || 0), 0);
+  const ms = Math.min(6e5, Math.max(5e3, Math.ceil(runtimeSec * 1e3 / 5e3) * 5e3));
+  return {
+    prompt: `${LOOK_MUSIC[film.look] ?? LOOK_MUSIC["live-action"]}. Instrumental only, no vocals. One consistent theme, loopable as a background bed under dialogue.`,
+    music_length_ms: ms,
+    force_instrumental: true,
+    output_format: "mp3_standard"
+  };
+}
+async function advance(filmId, soundtrack, musicJobId, ctx) {
+  const { data } = await filmApi(ctx, "GET", `/api/films/${filmId}?refresh=1`);
+  const film = data.film;
+  if (!film) return { kind: "text", text: `Film not found: ${data.error ?? filmId}` };
+  const all = shots(film);
+  if (film.status === "exported" && film.exportUrl) {
+    return {
+      kind: "text",
+      text: `Film finished: "${film.title}"
+Watch/download: ${film.exportUrl}
+Workspace: ${ctx.baseUrl}/film-studio/${film.id}
+It is saved in the Library folder "Film: ${film.title}".`
+    };
+  }
+  if (film.exportError) {
+    return { kind: "text", text: `Export failed: ${film.exportError} Poll again with action "status" to retry.` };
+  }
+  const idleFrames = all.filter((sh) => sh.status === "idle");
+  for (const sh of idleFrames.slice(0, 6)) {
+    await filmApi(ctx, "POST", `/api/films/${filmId}/shots/${sh.id}/generate`, { kind: "frame" });
+  }
+  const framesDone = all.every((sh) => ["frame-ready", "clip-generating", "clip-ready"].includes(sh.status));
+  if (framesDone && all.some((sh) => sh.status === "frame-ready" && !sh.approved)) {
+    await filmApi(ctx, "PATCH", `/api/films/${filmId}`, {
+      scenes: film.scenes.map((s) => ({
+        id: s.id,
+        title: s.title,
+        location: s.location,
+        shots: s.shots.map((sh) => ({
+          id: sh.id,
+          prompt: sh.prompt,
+          characterIds: sh.characterIds ?? [],
+          elementIds: sh.elementIds ?? [],
+          engine: sh.engine,
+          cameraPreset: sh.cameraPreset,
+          approved: true,
+          durationSec: sh.durationSec
+        }))
+      }))
+    });
+  }
+  const inFlight = count(film, (sh) => sh.status === "clip-generating");
+  const clipQueue = all.filter((sh) => (sh.status === "frame-ready" || sh.status === "failed" && Boolean(sh.frameUrl)) && framesDone);
+  for (const sh of clipQueue.slice(0, Math.max(0, 4 - inFlight))) {
+    await filmApi(ctx, "POST", `/api/films/${filmId}/shots/${sh.id}/generate`, { kind: "clip" });
+  }
+  const clipsDone = all.length > 0 && all.every((sh) => sh.status === "clip-ready");
+  if (clipsDone) {
+    const hasMusic = film.audioStems.some((st) => st.kind === "music");
+    if (soundtrack !== "none" && !hasMusic) {
+      if (musicJobId) {
+        const job = await ctx.client.getJob(musicJobId);
+        const out = job.output;
+        const outUrl = out?.audio ?? out?.video ?? out?.images?.[0];
+        if (job.status === "completed" && typeof outUrl === "string") {
+          await filmApi(ctx, "PATCH", `/api/films/${filmId}`, { audioStems: [{ kind: "music", url: outUrl }] });
+          await filmApi(ctx, "POST", `/api/films/${filmId}/export`, {});
+          return { kind: "text", text: `Score attached \u2014 export started. Poll again in ~60s with {"film_id": "${filmId}", "action": "status"} for the finished film URL.` };
+        }
+        if (job.status === "failed") {
+          return { kind: "text", text: `The score failed (${job.error ?? "unknown"}) and was refunded. Poll again to retry, or pass soundtrack "none" to export without music.` };
+        }
+        return { kind: "text", text: `Score still composing. Poll again in ~20s with {"film_id": "${filmId}", "action": "status", "music_job_id": "${musicJobId}"}.` };
+      }
+      const body = soundtrack === "scene-synced" ? buildScorePlanBody(film) : buildFlatMusicBody(film, all);
+      const dispatch = await ctx.client.run("text-to-music", body);
+      return { kind: "text", text: `All ${all.length} clips ready \u2014 the ${soundtrack} score is composing (charged like any music generation). Poll again in ~20s with {"film_id": "${filmId}", "action": "status", "music_job_id": "${dispatch.jobId}"}.` };
+    }
+    await filmApi(ctx, "POST", `/api/films/${filmId}/export`, {});
+    return { kind: "text", text: `All clips ready \u2014 export started (${progressLine(film)}). Poll again in ~60s with action "status" for the finished film URL.` };
+  }
+  const failed = all.filter((sh) => sh.status === "failed");
+  return {
+    kind: "text",
+    text: [
+      `In progress: ${progressLine(film)}.`,
+      failed.length > 0 ? `${failed.length} shot(s) failed and were re-queued (${failed[0]?.errorMessage?.slice(0, 100) ?? ""}).` : "",
+      `Poll again in ~30s with {"film_id": "${filmId}", "action": "status"}.`
+    ].filter(Boolean).join("\n")
+  };
+}
 async function run8(input, ctx) {
+  const action = input.action === "plan" && input.film_id ? "status" : input.action;
+  if (action === "plan") return plan(input, ctx);
+  if (!input.film_id) return { kind: "text", text: "produce/status need the film_id returned by the plan step." };
+  if (action === "produce") return produce(input.film_id, ctx);
+  return advance(input.film_id, input.soundtrack, input.music_job_id, ctx);
+}
+var LOOKS, InputSchema8, InputJsonSchema8, shots, count, LOOK_MUSIC, ARC, filmSkill;
+var init_film = __esm({
+  "src/skills/film.ts"() {
+    LOOKS = ["live-action", "anime", "3d-animation", "noir", "horror", "sci-fi", "documentary", "western", "romance", "romantic-comedy", "comedy"];
+    InputSchema8 = zod.z.object({
+      idea: zod.z.string().max(2e3).optional().describe("One-to-three sentence film idea. The studio writes the screenplay (free). Provide idea OR script for planning."),
+      script: zod.z.string().max(2e4).optional().describe("A full screenplay to plan instead of an idea (sluglines, action lines, dialogue)."),
+      look: zod.z.enum(LOOKS).default("live-action").describe("Visual style carried through frames, clips, and soundtrack."),
+      aspect: zod.z.enum(["16:9", "9:16"]).default("16:9"),
+      length: zod.z.enum(["30s", "60s", "2-3min", "5min"]).default("60s").describe("Target length; drives the shot count (~6/12/24/60 shots)."),
+      film_id: zod.z.string().max(40).optional().describe("Existing film id (from a previous call) for produce/status."),
+      action: zod.z.enum(["plan", "produce", "status"]).default("plan").describe("'plan' creates + storyboards (free). 'produce' starts charged generation. 'status' advances production and reports progress; poll it every ~30s until it returns the finished film."),
+      soundtrack: zod.z.enum(["scene-synced", "flat", "none"]).default("scene-synced").describe("scene-synced composes one musical section per scene, pinned to the scene lengths (default). flat is a single cohesive bed. none skips music."),
+      music_job_id: zod.z.string().max(80).optional().describe("Internal: pass back the music job id from a previous status reply so the composing score is attached instead of re-charged.")
+    });
+    InputJsonSchema8 = {
+      type: "object",
+      properties: {
+        idea: { type: "string", description: "One-to-three sentence film idea. The studio writes the screenplay (free)." },
+        script: { type: "string", description: "A full screenplay to plan instead of an idea." },
+        look: { type: "string", enum: [...LOOKS], description: "Visual style. Default live-action." },
+        aspect: { type: "string", enum: ["16:9", "9:16"], description: "Default 16:9." },
+        length: { type: "string", enum: ["30s", "60s", "2-3min", "5min"], description: "Target length (~6/12/24/60 shots). Default 60s." },
+        film_id: { type: "string", description: "Existing film id for produce/status." },
+        action: { type: "string", enum: ["plan", "produce", "status"], description: "plan (free) | produce (charged) | status (poll every ~30s)." },
+        soundtrack: { type: "string", enum: ["scene-synced", "flat", "none"], description: "Default scene-synced." },
+        music_job_id: { type: "string", description: "Pass back from a previous status reply while the score is composing." }
+      }
+    };
+    shots = (f) => f.scenes.flatMap((s) => s.shots);
+    count = (f, pred) => shots(f).filter(pred).length;
+    LOOK_MUSIC = {
+      "live-action": "modern cinematic underscore, warm strings and soft felt piano, subtle rhythmic pulse, slow emotional build",
+      anime: "sweeping anime film score, lush strings and piano, taiko drum accents, soaring heartfelt theme",
+      "3d-animation": "playful heartfelt family-animation score, pizzicato strings, celesta and warm woodwinds, gentle sense of wonder",
+      noir: "smoky film-noir jazz underscore, brushed drums, upright bass, distant muted trumpet, slow simmering tension",
+      horror: "sparse horror underscore, low cello drones, dissonant string swells, creeping heartbeat pulse, unsettling quiet",
+      "sci-fi": "atmospheric science-fiction score, analog synth pads, deep sub-bass pulses, shimmering arpeggios, vast and cold",
+      documentary: "understated documentary score, felt piano, soft string beds, organic percussion textures, reflective and true",
+      western: "cinematic western score, lonely twangy guitar, dusty strings, distant horns, wide-open desert tension",
+      romance: "tender romantic score, felt piano and warm strings, soft acoustic guitar, intimate and unhurried, gently swelling",
+      "romantic-comedy": "bright romantic-comedy score, plucky ukulele and handclaps, warm brushed drums, sunny and flirtatious",
+      comedy: "playful comedy score, bouncy pizzicato strings, cheeky woodwinds, light percussion hits punctuating the gags"
+    };
+    ARC = {
+      opening: ["establishing the theme", "restrained", "quiet anticipation"],
+      middle: ["building tension", "rising intensity", "forward motion"],
+      finale: ["climactic", "full arrangement", "emotional peak resolving to stillness"]
+    };
+    filmSkill = {
+      name: "pixeldojo_film",
+      description: "Make a finished short film from one idea: screenplay, storyboard frames (AI-reviewed), video clips with spoken dialogue, scene-synced soundtrack, stitched export. Phased: plan is free and returns a cost estimate; produce starts charged generation; status advances production (poll every ~30s).",
+      inputZod: InputSchema8,
+      inputJsonSchema: InputJsonSchema8,
+      allowedModels: [],
+      defaultModel: "",
+      run: run8
+    };
+  }
+});
+async function run9(input, ctx) {
   const productImages = [
     ...input.product_image_urls ?? [],
     ...await Promise.all((input.product_image_paths ?? []).map((p) => uploadLocalFile(p, ctx.client)))
@@ -978,13 +1373,13 @@ async function run8(input, ctx) {
     (urls) => urls.length === 0 ? `Ad job ${submitted.jobId} completed but returned no assets.` : `Ad rendered (style: ${styleLabel}${submitted.ad?.product?.name ? `, product: ${submitted.ad.product.name}` : ""}). Video: ${urls[0]}`
   );
 }
-var InputSchema8, InputJsonSchema8, adSkill;
+var InputSchema9, InputJsonSchema9, adSkill;
 var init_ad = __esm({
   "src/skills/ad.ts"() {
     init_types();
     init_poll();
     init_upload_helpers();
-    InputSchema8 = zod.z.object({
+    InputSchema9 = zod.z.object({
       style: zod.z.string().max(80).optional().describe(
         "Ad style slug (default ugc-testimonial). Catalog: GET /api/v1/marketing/presets \u2014 e.g. ugc-testimonial, unboxing-reveal, unboxing-asmr, virtual-try-on, street-style, product-showcase, macro-details, crush-test, hyper-motion, before-after, day-in-the-life, the-gift, tv-spot."
       ),
@@ -1010,7 +1405,7 @@ var init_ad = __esm({
         path: ["product_url"]
       }
     );
-    InputJsonSchema8 = {
+    InputJsonSchema9 = {
       type: "object",
       properties: {
         style: {
@@ -1064,18 +1459,18 @@ var init_ad = __esm({
       // Zod refine; no root-level oneOf (Grok rejects non-object root unions).
     };
     adSkill = {
-      name: "pixeldojo:ad",
-      description: "Marketing Studio: turn any product into a video ad. Pass a product URL (auto-extracted) or product images, pick an ad style (UGC testimonial, unboxing, try-on, showcase, TV spot, and more via GET /api/v1/marketing/presets), optionally add presenter reference images, a location, a hook, and the exact spoken script. Renders with voiceover; returns the video or a statusUrl handoff to poll via pixeldojo:status. Ideal for automated generate-and-post workflows.",
-      inputZod: InputSchema8,
-      inputJsonSchema: InputJsonSchema8,
+      name: "pixeldojo_ad",
+      description: "Marketing Studio: turn any product into a video ad. Pass a product URL (auto-extracted) or product images, pick an ad style (UGC testimonial, unboxing, try-on, showcase, TV spot, and more via GET /api/v1/marketing/presets), optionally add presenter reference images, a location, a hook, and the exact spoken script. Renders with voiceover; returns the video or a statusUrl handoff to poll via pixeldojo_status. Ideal for automated generate-and-post workflows.",
+      inputZod: InputSchema9,
+      inputJsonSchema: InputJsonSchema9,
       // Composition skill — the server routes to the ad engine internally.
       allowedModels: [],
       defaultModel: "",
-      run: run8
+      run: run9
     };
   }
 });
-async function run9(input, ctx) {
+async function run10(input, ctx) {
   const client = ctx.client;
   const result = await client.runCampaign(input);
   if (result.kind === "campaign") {
@@ -1097,15 +1492,15 @@ async function run9(input, ctx) {
   }
   return {
     kind: "handoff",
-    text: result.message ?? `Campaign ${result.campaignId} queued. Poll via pixeldojo:campaign_status.`,
+    text: result.message ?? `Campaign ${result.campaignId} queued. Poll via pixeldojo_campaign_status.`,
     jobId: result.campaignId,
     statusUrl: result.statusUrl ?? ctx.buildStatusUrl(result.campaignId)
   };
 }
-var InputSchema9, InputJsonSchema9, campaignSkill;
+var InputSchema10, InputJsonSchema10, campaignSkill;
 var init_campaign = __esm({
   "src/skills/campaign.ts"() {
-    InputSchema9 = zod.z.object({
+    InputSchema10 = zod.z.object({
       productUrl: zod.z.string().url().optional().describe("Product page URL. We extract name + description + images automatically."),
       product: zod.z.object({
         name: zod.z.string().min(1).max(200),
@@ -1121,7 +1516,7 @@ var init_campaign = __esm({
       message: "productUrl or product is required",
       path: ["productUrl"]
     });
-    InputJsonSchema9 = {
+    InputJsonSchema10 = {
       type: "object",
       properties: {
         productUrl: {
@@ -1150,19 +1545,19 @@ var init_campaign = __esm({
       oneOf: [{ required: ["productUrl"] }, { required: ["product"] }]
     };
     campaignSkill = {
-      name: "pixeldojo:campaign",
-      description: "Generate a coherent product launch package (hero image + N lifestyle variants + optional vertical video) from one URL or product profile. Composes hero / lifestyle / video models server-side; returns assets in one call or a handoff with campaignId to poll via pixeldojo:campaign_status.",
-      inputZod: InputSchema9,
-      inputJsonSchema: InputJsonSchema9,
+      name: "pixeldojo_campaign",
+      description: "Generate a coherent product launch package (hero image + N lifestyle variants + optional vertical video) from one URL or product profile. Composes hero / lifestyle / video models server-side; returns assets in one call or a handoff with campaignId to poll via pixeldojo_campaign_status.",
+      inputZod: InputSchema10,
+      inputJsonSchema: InputJsonSchema10,
       // Composition skill — internal sub-jobs route to per-tool models, no
       // single allowed-models list applies here.
       allowedModels: [],
       defaultModel: "",
-      run: run9
+      run: run10
     };
   }
 });
-async function run10(input, ctx) {
+async function run11(input, ctx) {
   const client = ctx.client;
   const result = await client.getCampaign(input.campaignId);
   if (result.kind === "campaign") {
@@ -1192,40 +1587,40 @@ async function run10(input, ctx) {
     statusUrl: result.statusUrl ?? ctx.buildStatusUrl(result.campaignId)
   };
 }
-var InputSchema10, InputJsonSchema10, campaignStatusSkill;
+var InputSchema11, InputJsonSchema11, campaignStatusSkill;
 var init_campaign_status = __esm({
   "src/skills/campaign-status.ts"() {
-    InputSchema10 = zod.z.object({
-      campaignId: zod.z.string().min(1).max(200).describe("Campaign id returned from a prior pixeldojo:campaign handoff.")
+    InputSchema11 = zod.z.object({
+      campaignId: zod.z.string().min(1).max(200).describe("Campaign id returned from a prior pixeldojo_campaign handoff.")
     });
-    InputJsonSchema10 = {
+    InputJsonSchema11 = {
       type: "object",
       properties: {
         campaignId: {
           type: "string",
-          description: "Campaign id returned from a prior pixeldojo:campaign handoff."
+          description: "Campaign id returned from a prior pixeldojo_campaign handoff."
         }
       },
       required: ["campaignId"]
     };
     campaignStatusSkill = {
-      name: "pixeldojo:campaign_status",
-      description: "Poll a campaign by campaignId returned from pixeldojo:campaign. Returns assets when every sub-job is done, or a handoff describing what is still in flight.",
-      inputZod: InputSchema10,
-      inputJsonSchema: InputJsonSchema10,
+      name: "pixeldojo_campaign_status",
+      description: "Poll a campaign by campaignId returned from pixeldojo_campaign. Returns assets when every sub-job is done, or a handoff describing what is still in flight.",
+      inputZod: InputSchema11,
+      inputJsonSchema: InputJsonSchema11,
       allowedModels: [],
       defaultModel: "",
-      run: run10
+      run: run11
     };
   }
 });
-async function run11(input, ctx) {
+async function run12(input, ctx) {
   let url;
   try {
     url = await uploadLocalFile(input.path, ctx.client);
   } catch (err) {
     if (err instanceof SkillUploadError) {
-      return { kind: "text", text: `pixeldojo:upload: ${err.userMessage}` };
+      return { kind: "text", text: `pixeldojo_upload: ${err.userMessage}` };
     }
     throw err;
   }
@@ -1235,16 +1630,16 @@ async function run11(input, ctx) {
 (temp storage; auto-deletes in ~24h \u2014 pass this URL as image_url to :generate or :edit)`
   };
 }
-var InputSchema11, InputJsonSchema11, uploadSkill;
+var InputSchema12, InputJsonSchema12, uploadSkill;
 var init_upload = __esm({
   "src/skills/upload.ts"() {
     init_upload_helpers();
-    InputSchema11 = zod.z.object({
+    InputSchema12 = zod.z.object({
       path: zod.z.string().min(1).max(4096).describe(
         "Absolute local file path to upload. JPEG, PNG, WebP, GIF (\u226450MB) or MP4, WebM, MOV (\u2264200MB). Returns a public URL on the temp CDN; storage auto-expires after 24 hours."
       )
     });
-    InputJsonSchema11 = {
+    InputJsonSchema12 = {
       type: "object",
       properties: {
         path: {
@@ -1255,22 +1650,22 @@ var init_upload = __esm({
       required: ["path"]
     };
     uploadSkill = {
-      name: "pixeldojo:upload",
+      name: "pixeldojo_upload",
       description: "Upload a local image or video file and get back a public URL you can pass to :generate or :edit as image_url. Use when the user has a reference image on disk (drag-dropped into Claude Code, screenshot, etc.) and you need a URL. Storage auto-expires after 24 hours.",
-      inputZod: InputSchema11,
-      inputJsonSchema: InputJsonSchema11,
+      inputZod: InputSchema12,
+      inputJsonSchema: InputJsonSchema12,
       allowedModels: [],
       defaultModel: "",
-      run: run11
+      run: run12
     };
   }
 });
-async function run12(input, ctx) {
+async function run13(input, ctx) {
   const requested = input.model ?? DEFAULT_MODEL6;
   if (!ALLOWED4.includes(requested)) {
     return {
       kind: "text",
-      text: `Unknown model "${requested}" for pixeldojo:audio. Allowed: ${ALLOWED4.join(", ")}.`
+      text: `Unknown model "${requested}" for pixeldojo_audio. Allowed: ${ALLOWED4.join(", ")}.`
     };
   }
   const apiId = requested;
@@ -1281,7 +1676,7 @@ async function run12(input, ctx) {
       audioUrls = [...audioUrls, ...uploaded].slice(0, 3);
     } catch (err) {
       if (err instanceof SkillUploadError) {
-        return { kind: "text", text: `pixeldojo:audio (upload): ${err.userMessage}` };
+        return { kind: "text", text: `pixeldojo_audio (upload): ${err.userMessage}` };
       }
       throw err;
     }
@@ -1314,7 +1709,7 @@ async function run12(input, ctx) {
     (urls) => urls.length === 0 ? `Job ${submitted.jobId} completed but returned no assets.` : `Audio ready. Asset: ${urls[0]}`
   );
 }
-var ALLOWED4, DEFAULT_MODEL6, InputSchema12, InputJsonSchema12, audioSkill;
+var ALLOWED4, DEFAULT_MODEL6, InputSchema13, InputJsonSchema13, audioSkill;
 var init_audio = __esm({
   "src/skills/audio.ts"() {
     init_poll();
@@ -1322,7 +1717,7 @@ var init_audio = __esm({
     init_types();
     ALLOWED4 = ["seed-audio", "text-to-speech"];
     DEFAULT_MODEL6 = "seed-audio";
-    InputSchema12 = zod.z.object({
+    InputSchema13 = zod.z.object({
       prompt: zod.z.string().min(1).describe(
         "A script for speech, or a scene description for cinematic audio (dialogue + effects + music). Reference uploaded clips as @Audio1..@Audio3."
       ),
@@ -1333,7 +1728,7 @@ var init_audio = __esm({
       output_format: zod.z.string().optional().describe("seed-audio: mp3 (default), wav, pcm, ogg_opus. text-to-speech: mp3, wav, flac, pcm."),
       speed: zod.z.number().min(0.5).max(2).optional().describe("Speech speed multiplier (0.5\u20132).")
     });
-    InputJsonSchema12 = {
+    InputJsonSchema13 = {
       type: "object",
       properties: {
         prompt: { type: "string" },
@@ -1347,17 +1742,17 @@ var init_audio = __esm({
       required: ["prompt"]
     };
     audioSkill = {
-      name: "pixeldojo:audio",
+      name: "pixeldojo_audio",
       description: "Generate audio: speech, multi-character dialogue, sound effects, and background music from one prompt (Seed Audio 1.0 by default; plain TTS available).",
-      inputZod: InputSchema12,
-      inputJsonSchema: InputJsonSchema12,
+      inputZod: InputSchema13,
+      inputJsonSchema: InputJsonSchema13,
       allowedModels: [...ALLOWED4],
       defaultModel: DEFAULT_MODEL6,
-      run: run12
+      run: run13
     };
   }
 });
-async function run13(input, ctx) {
+async function run14(input, ctx) {
   const res = await ctx.client.listLibrary({
     q: input.q,
     model: input.model,
@@ -1367,7 +1762,7 @@ async function run13(input, ctx) {
   if (res.items.length === 0) {
     return {
       kind: "text",
-      text: input.q ? `No library items match "${input.q}". Try a broader query, or omit q to list recent generations.` : "Your library is empty. Generate something with pixeldojo:generate first."
+      text: input.q ? `No library items match "${input.q}". Try a broader query, or omit q to list recent generations.` : "Your library is empty. Generate something with pixeldojo_generate first."
     };
   }
   const lines = res.items.map((it) => {
@@ -1388,16 +1783,16 @@ ${lines.join("\n")}
 Pass any URL back into :generate, :edit, :character, or :upscale as a reference input.`
   };
 }
-var InputSchema13, InputJsonSchema13, librarySkill;
+var InputSchema14, InputJsonSchema14, librarySkill;
 var init_library = __esm({
   "src/skills/library.ts"() {
-    InputSchema13 = zod.z.object({
+    InputSchema14 = zod.z.object({
       q: zod.z.string().optional().describe("Substring match against the prompt that produced the asset."),
       model: zod.z.string().optional().describe("Restrict to a single model (apiId)."),
       modality: zod.z.enum(["image", "video", "audio"]).optional().describe("Restrict to one output type."),
       limit: zod.z.number().int().min(1).max(50).optional().describe("Max results (default 10).")
     });
-    InputJsonSchema13 = {
+    InputJsonSchema14 = {
       type: "object",
       properties: {
         q: { type: "string" },
@@ -1408,17 +1803,17 @@ var init_library = __esm({
       required: []
     };
     librarySkill = {
-      name: "pixeldojo:library",
-      description: "Search your media library: saved My Media items (permanent) and recent API/MCP generations (expire after 24h), newest first. Returns asset URLs to reuse as reference inputs. Keep a result forever with pixeldojo:save.",
-      inputZod: InputSchema13,
-      inputJsonSchema: InputJsonSchema13,
+      name: "pixeldojo_library",
+      description: "Search your media library: saved My Media items (permanent) and recent API/MCP generations (expire after 24h), newest first. Returns asset URLs to reuse as reference inputs. Keep a result forever with pixeldojo_save.",
+      inputZod: InputSchema14,
+      inputJsonSchema: InputJsonSchema14,
       allowedModels: [],
       defaultModel: "",
-      run: run13
+      run: run14
     };
   }
 });
-async function run14(input, ctx) {
+async function run15(input, ctx) {
   const res = await ctx.client.saveMedia({
     url: input.url,
     prompt: input.prompt,
@@ -1429,20 +1824,20 @@ async function run14(input, ctx) {
   return {
     kind: "text",
     text: `Saved to My Media (permanent): ${res.url}
-It will appear at https://pixeldojo.ai/my-images and in pixeldojo:library searches.`
+It will appear at https://pixeldojo.ai/my-images and in pixeldojo_library searches.`
   };
 }
-var InputSchema14, InputJsonSchema14, saveSkill;
+var InputSchema15, InputJsonSchema15, saveSkill;
 var init_save = __esm({
   "src/skills/save.ts"() {
-    InputSchema14 = zod.z.object({
+    InputSchema15 = zod.z.object({
       url: zod.z.string().url().describe("The asset URL to save (image or video)."),
       prompt: zod.z.string().optional().describe("The prompt that produced it \u2014 makes it findable in the library later."),
       tool_name: zod.z.string().optional().describe("Tool/model slug that produced it."),
       modality: zod.z.enum(["image", "video", "audio"]).optional(),
       job_id: zod.z.string().optional().describe("The jobId that produced this asset, when known.")
     });
-    InputJsonSchema14 = {
+    InputJsonSchema15 = {
       type: "object",
       properties: {
         url: { type: "string", format: "uri" },
@@ -1454,13 +1849,13 @@ var init_save = __esm({
       required: ["url"]
     };
     saveSkill = {
-      name: "pixeldojo:save",
+      name: "pixeldojo_save",
       description: "Save a generated image or video into the user's My Media library permanently. Generation outputs otherwise expire after 24 hours \u2014 call this when the user wants to keep a result.",
-      inputZod: InputSchema14,
-      inputJsonSchema: InputJsonSchema14,
+      inputZod: InputSchema15,
+      inputJsonSchema: InputJsonSchema15,
       allowedModels: [],
       defaultModel: "",
-      run: run14
+      run: run15
     };
   }
 });
@@ -1502,7 +1897,7 @@ async function runSave(input, ctx) {
   });
   return {
     kind: "text",
-    text: res.created ? `Saved workflow "${res.name}" (${res.steps} step${res.steps === 1 ? "" : "s"}). Run it with pixeldojo:run_workflow { name: "${res.name}" }.` : `Overwrote workflow "${res.name}" (${res.steps} step${res.steps === 1 ? "" : "s"}).`
+    text: res.created ? `Saved workflow "${res.name}" (${res.steps} step${res.steps === 1 ? "" : "s"}). Run it with pixeldojo_run_workflow { name: "${res.name}" }.` : `Overwrote workflow "${res.name}" (${res.steps} step${res.steps === 1 ? "" : "s"}).`
   };
 }
 async function runList(_input, ctx) {
@@ -1510,7 +1905,7 @@ async function runList(_input, ctx) {
   if (res.count === 0) {
     return {
       kind: "text",
-      text: "No saved workflows yet. Save one with pixeldojo:save_workflow { name, steps: [{ skill, args }] }."
+      text: "No saved workflows yet. Save one with pixeldojo_save_workflow { name, steps: [{ skill, args }] }."
     };
   }
   const lines = res.workflows.map(
@@ -1579,7 +1974,7 @@ async function runWorkflow(input, ctx) {
     } else if (result.kind === "handoff") {
       return {
         kind: "text",
-        text: `Workflow "${workflow.name}" is still on step ${i + 1} (${step.skill}) after an extended wait. Poll with pixeldojo:status { jobId: "${result.jobId}" }, then re-run the workflow once it completes.`
+        text: `Workflow "${workflow.name}" is still on step ${i + 1} (${step.skill}) after an extended wait. Poll with pixeldojo_status { jobId: "${result.jobId}" }, then re-run the workflow once it completes.`
       };
     } else {
       outputs.push(`step ${i + 1} (${step.skill}): done (no asset URL)`);
@@ -1598,7 +1993,7 @@ var init_workflows = __esm({
     init_types();
     WORKFLOW_STEP_EXTRA_BUDGET_MS = 6e4;
     StepSchema = zod.z.object({
-      skill: zod.z.string().regex(/^pixeldojo:(generate|edit|character|storyboard|upscale|audio|upload|from_url)$/, {
+      skill: zod.z.string().regex(/^pixeldojo[:_](generate|edit|character|storyboard|upscale|audio|upload|from_url)$/, {
         message: "Runnable skills only: generate, edit, character, storyboard, upscale, audio, upload, from_url."
       }),
       args: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
@@ -1624,7 +2019,7 @@ var init_workflows = __esm({
       required: ["skill"]
     };
     saveWorkflowSkill = {
-      name: "pixeldojo:save_workflow",
+      name: "pixeldojo_save_workflow",
       description: "Save a named multi-step skill chain (generate \u2192 edit \u2192 upscale \u2026). String args may contain {{input.<key>}} and {{prev}} placeholders. Saving to an existing name overwrites it.",
       inputZod: SaveInputSchema,
       inputJsonSchema: {
@@ -1641,7 +2036,7 @@ var init_workflows = __esm({
       run: runSave
     };
     runWorkflowSkill = {
-      name: "pixeldojo:run_workflow",
+      name: "pixeldojo_run_workflow",
       description: "Run a saved workflow by name. Pass inputs for its {{input.<key>}} placeholders; each step feeds the next via {{prev}}.",
       inputZod: RunInputSchema,
       inputJsonSchema: {
@@ -1657,7 +2052,7 @@ var init_workflows = __esm({
       run: runWorkflow
     };
     listWorkflowsSkill = {
-      name: "pixeldojo:list_workflows",
+      name: "pixeldojo_list_workflows",
       description: "List your saved workflows with step counts and run totals.",
       inputZod: ListInputSchema,
       inputJsonSchema: { type: "object", properties: {}, required: [] },
@@ -1678,6 +2073,7 @@ __export(skills_exports, {
   campaignStatusSkill: () => campaignStatusSkill,
   characterSkill: () => characterSkill,
   editSkill: () => editSkill,
+  filmSkill: () => filmSkill,
   findSkill: () => findSkill,
   fromUrlSkill: () => fromUrlSkill,
   generateSkill: () => generateSkill,
@@ -1692,7 +2088,8 @@ __export(skills_exports, {
   upscaleSkill: () => upscaleSkill
 });
 function findSkill(name) {
-  return exports.ALL_SKILLS.find((s) => s.name === name);
+  const wanted = name.replace(/^pixeldojo:/, "pixeldojo_");
+  return exports.ALL_SKILLS.find((s) => s.name === wanted);
 }
 exports.ALL_SKILLS = void 0;
 var init_skills = __esm({
@@ -1704,6 +2101,7 @@ var init_skills = __esm({
     init_upscale();
     init_status();
     init_from_url();
+    init_film();
     init_ad();
     init_campaign();
     init_campaign_status();
@@ -1729,7 +2127,8 @@ var init_skills = __esm({
       uploadSkill,
       adSkill,
       campaignSkill,
-      campaignStatusSkill
+      campaignStatusSkill,
+      filmSkill
     ];
   }
 });
@@ -1784,7 +2183,7 @@ function makeRedactedLogger(target = console) {
 }
 
 // src/server.ts
-var PACKAGE_VERSION = "0.8.0" ;
+var PACKAGE_VERSION = "0.9.1" ;
 function buildServer(options) {
   if (!options.apiKey) {
     throw new Error(
@@ -1851,6 +2250,8 @@ function buildServer(options) {
     });
     const ctx = {
       client,
+      apiKey: options.apiKey,
+      baseUrl,
       mcpVersion: version,
       logger,
       buildStatusUrl: (jobId) => `${baseUrl}/api/v1/jobs/${encodeURIComponent(jobId)}`