@cueframe/kernel 0.2.57 → 0.2.59-rc.0

package/dist/authoring.js

@@ -4,64 +4,58 @@ import {
   hasSceneOp,
   isSceneOp,
   materializeSceneOpsCore
-} from "./chunk-N2OZDD44.js";
-import {
-  ZERO_USAGE,
-  buildDirectorTools,
-  buildPlannerTools,
-  buildToolsFromSchemas,
-  extractProviderError
-} from "./chunk-RERR5JLM.js";
-import {
-  COMPOSE_MOTION_TOOLS,
-  COMPOSE_MOTION_VERIFY_TOOLS,
-  COMPOSE_PLANNER_REPAIR_TOOLS,
-  COMPOSE_PLANNER_TOOLS,
-  COMPOSE_ROLE_TOOLS,
-  COMPOSE_ROLE_TOOL_NAMES,
-  dispatchComposeRoleTool
-} from "./chunk-LBN5KQC6.js";
-import {
-  AgentFixableCaptureError,
-  getExcludedTools
-} from "./chunk-JOURGVOR.js";
+} from "./chunk-6HA55CRU.js";
 import {
   buildDirectorContext
-} from "./chunk-UMXES6ED.js";
+} from "./chunk-LVMWPFV4.js";
 import {
   buildFastModel,
   buildModel,
   makeLangfuseFetch
-} from "./chunk-GCQ7Z7S7.js";
+} from "./chunk-KKATUGRU.js";
+import "./chunk-CIOUDOGN.js";
 import {
-  PipelineTrace
-} from "./chunk-GF52TW4I.js";
+  MOTION_PRESETS,
+  MotionPresetError,
+  generateMotionShell,
+  hasMotionPresetOp,
+  isMotionPresetOp,
+  materializeMotionPresetOpsCore,
+  resolveMotionPresetCard
+} from "./chunk-RR7UBEBV.js";
 import {
-  CODE_GEN_FEW_SHOT_EXAMPLES,
-  COMPONENT_CONTRACT,
-  DESIGN_QUALITY_RULES,
   EVALUATOR_PROMPT,
   PLANNING_INSTRUCTIONS,
-  TOOLKIT_REFERENCE,
   buildExecutionTask,
   buildPlannerUserMessage,
-  formatPlanSteps,
-  initCodeGenPrompts
-} from "./chunk-Y4HPN4BC.js";
-import "./chunk-7AZLFN26.js";
-import "./chunk-LBJ5LI5V.js";
-import "./chunk-AXRSCHQX.js";
-import "./chunk-UFD4EZHM.js";
+  formatPlanSteps
+} from "./chunk-VBYINB74.js";
+import {
+  canonicalJson
+} from "./chunk-XHMKPTHV.js";
+import {
+  getPrimitiveSubtextParam,
+  getPrimitiveTextParam
+} from "./chunk-EISHFHU5.js";
+import {
+  selectAllOverlays
+} from "./chunk-2K2GBFLU.js";
+import {
+  ComposePlan
+} from "./chunk-ZCEYEIRB.js";
+import "./chunk-6KZCXAYL.js";
+import {
+  OverlayClipSource
+} from "./chunk-AFUITAH6.js";
 import "./chunk-WPZKOVYF.js";
 import "./chunk-B7J5UUUV.js";
-import "./chunk-KYRDKK2D.js";
-import "./chunk-MZB4ZXYW.js";
-import {
-  cssLayoutVars
-} from "./chunk-DKBFAQCW.js";
+import "./chunk-EQH37KNZ.js";
+import "./chunk-Q6CJ6HCU.js";
 import "./chunk-WREYUH2E.js";
+import "./chunk-IVFMOHAC.js";
+import "./chunk-DKBFAQCW.js";
 import "./chunk-ILO4NEZ3.js";
-import "./chunk-E63UEO5C.js";
+import "./chunk-XQGQ5EFS.js";
 import "./chunk-7PA7FGLD.js";
 import "./chunk-VG2ND6PX.js";
 import {
@@ -70,11 +64,522 @@ import {
 } from "./chunk-CL5Y6V6K.js";
 import "./chunk-2L7PYYJK.js";
 import "./chunk-OOL7ZUG7.js";
-import "./chunk-2ESYSVXG.js";
+import "./chunk-U67V476Y.js";
 
 // ../authoring/src/agent.ts
 import { ToolLoopAgent, generateText, isStepCount } from "ai";
 
+// ../authoring/src/capabilities.ts
+var AgentFixableCaptureError = class extends Error {
+  agentFixable = true;
+  constructor(message) {
+    super(message);
+    this.name = "AgentFixableCaptureError";
+  }
+};
+var CAPABILITY_GATED_TOOLS = Object.freeze({
+  capture_frames: "capture",
+  score_composition: "verify",
+  apply_motion_preset: "motionPreset",
+  search_library: "resources"
+});
+function getExcludedTools(capabilities) {
+  const ex = /* @__PURE__ */ new Set();
+  for (const [tool2, cap] of Object.entries(CAPABILITY_GATED_TOOLS)) {
+    if (!capabilities[cap]) ex.add(tool2);
+  }
+  return ex;
+}
+
+// ../authoring/src/agent/buildTools.ts
+import { tool } from "ai";
+
+// ../authoring/src/tools/toolSets.ts
+var COMPOSE_PLANNER_TOOLS = [
+  "get_context",
+  "get_word_timings",
+  "search_library",
+  "capture_frames",
+  "submit_compose_plan"
+];
+var COMPOSE_PLANNER_REPAIR_TOOLS = [
+  "get_context",
+  "get_word_timings",
+  "search_library",
+  "capture_frames",
+  "amend_compose_plan"
+];
+var COMPOSE_MOTION_TOOLS = [
+  "get_context",
+  "get_word_timings",
+  "inspect_overlay",
+  "capture_frames",
+  "update_overlay",
+  "apply_motion_preset",
+  "score_composition"
+];
+var COMPOSE_MOTION_VERIFY_TOOLS = COMPOSE_MOTION_TOOLS.filter(
+  (t) => t !== "update_overlay" && t !== "apply_motion_preset"
+);
+
+// ../authoring/src/tools/composeRoleTools.ts
+import { z } from "zod";
+function overlayViews(capabilities) {
+  return selectAllOverlays(capabilities.composition.getState().composition).flatMap(
+    (o) => o.source.kind === "overlay" ? [{
+      id: o.id,
+      template: o.source.primitiveId,
+      startTime: o.startTime,
+      duration: o.duration,
+      params: { ...o.source.params }
+    }] : []
+  );
+}
+var COMPOSE_ROLE_TOOLS = Object.freeze({
+  get_context: {
+    name: "get_context",
+    description: "Get current project state: transcript with word-level timings, clips on timeline, overlays, brand kit, imported assets, playhead time, timeline duration, and FPS. Always call this first.",
+    schema: z.object({}),
+    metadata: { label: "Get Context" },
+    handler: async (_args, capabilities) => {
+      const { buildDirectorContext: buildDirectorContext2 } = await import("./context-7SWSVJ6Z.js");
+      return buildDirectorContext2(capabilities);
+    }
+  },
+  get_word_timings: {
+    name: "get_word_timings",
+    description: "Get precise word-level timestamps for a section of the transcript. Call this BEFORE you name a cut range, so the range lands on real word boundaries instead of a rounded guess. On the library page, pass poolItemId to read a specific media item.",
+    schema: z.object({
+      startTime: z.coerce.number().min(0).describe("Start of time range in seconds"),
+      endTime: z.coerce.number().min(0).describe("End of time range in seconds"),
+      poolItemId: z.string().optional().describe("Pool item ID to read. If omitted, reads the current timeline transcript.")
+    }),
+    metadata: { label: "Get Word Timings" },
+    inputExamples: [{ input: { startTime: 12, endTime: 15 } }],
+    handler: async (args, capabilities) => {
+      const startTime = args.startTime;
+      const endTime = args.endTime;
+      if (endTime <= startTime) {
+        return { error: `Invalid range: endTime (${endTime}) must be greater than startTime (${startTime})` };
+      }
+      return capabilities.transcript.getWordTimings(startTime, endTime);
+    }
+  },
+  inspect_overlay: {
+    name: "inspect_overlay",
+    description: "Retrieve the full details of an existing overlay, including its JSX source code. Use this to inspect fonts, colors, animations, or any implementation detail of a placed overlay.",
+    schema: z.object({
+      id: z.string().describe("The ID of the overlay to inspect")
+    }),
+    metadata: { label: "Inspect Overlay" },
+    strict: true,
+    handler: async (args, capabilities) => {
+      const overlay = overlayViews(capabilities).find((o) => o.id === args.id);
+      if (!overlay) return { error: `Overlay ${args.id} not found` };
+      const lines = [
+        `Overlay ${overlay.id}:`,
+        `  template: ${overlay.template}`,
+        `  startTime: ${overlay.startTime}s`,
+        `  duration: ${overlay.duration}s`,
+        `  text: "${overlay.params.text}"`
+      ];
+      if (overlay.params.subtext) lines.push(`  subtext: "${overlay.params.subtext}"`);
+      if (overlay.params.position) lines.push(`  position: ${overlay.params.position}`);
+      if (overlay.params.accentColor) lines.push(`  accentColor: ${overlay.params.accentColor}`);
+      if (overlay.params.transition) lines.push(`  transition: ${overlay.params.transition}`);
+      if (overlay.params.sequenceGroup) lines.push(`  sequenceGroup: ${overlay.params.sequenceGroup}`);
+      if (overlay.params.jsxSource) {
+        lines.push(`
+Source code:
+${overlay.params.jsxSource}`);
+      } else {
+        lines.push(`
+(No custom source code \u2014 uses built-in template rendering)`);
+      }
+      return lines.join("\n");
+    }
+  },
+  update_overlay: {
+    name: "update_overlay",
+    description: "Update properties of an existing motion graphic overlay. Only include the fields you want to change. Provide authored jsxSource to re-generate a custom component.",
+    schema: z.object({
+      id: z.string().min(1).describe("The overlay clip ID (a UUID). Use the exact id inspect_overlay reports \u2014 never fabricate IDs."),
+      startTime: z.coerce.number().min(0).optional().describe("New start time in seconds"),
+      duration: z.coerce.number().min(0.5).max(60).optional().describe("New duration in seconds"),
+      text: z.string().min(1).max(200).optional().describe("New primary text"),
+      subtext: z.string().max(200).optional().describe("New secondary text"),
+      position: z.string().optional().transform((v) => {
+        if (!v) return v;
+        const match = v.match(/(left|center|right)/i);
+        return match ? match[1].toLowerCase() : "center";
+      }),
+      accentColor: z.string().regex(/^#[0-9a-fA-F]{3,8}$/, "Must be a hex color (e.g., #D4AF37)").optional().describe("New accent color as hex"),
+      textColor: z.string().regex(/^#[0-9a-fA-F]{3,8}$/, "Must be a hex color").optional().describe("New text color as hex"),
+      fontFamily: z.string().optional().describe("New font family"),
+      backgroundColor: z.string().regex(/^#[0-9a-fA-F]{3,8}$/, "Must be a hex color").optional().describe("New background color as hex"),
+      jsxSource: z.string().max(5e4).optional().describe("New canonical TSX module source for the overlay"),
+      transition: z.enum(["fade", "slide", "wipe", "none"]).optional().describe("New transition type"),
+      sequenceGroup: z.string().optional().describe("New sequence group ID"),
+      primitiveId: z.string().optional().describe(
+        'Switch the overlay to a different primitive component ID (e.g. "lower-third", "heroText"). Omit to keep the current primitive.'
+      ),
+      params: z.record(z.string(), z.unknown()).optional().describe(
+        "Per-primitive params bag to merge over the overlay\u2019s existing params. Only the keys you set change; existing params are preserved."
+      ),
+      zPlane: OverlayClipSource.shape.zPlane.describe(
+        'Depth plane. "front" renders over the video; "behind-subject" renders UNDER the subject cut-out (the launch-video hero-text look). Omit to keep the overlay\u2019s current plane.'
+      ),
+      parallax: OverlayClipSource.shape.parallax.describe(
+        "Depth parallax for a behind-subject overlay (differential motion vs the camera; 0 locks to the scene). Omit to keep the current value."
+      ),
+      anchor: z.object({
+        x: z.number().min(0).max(1).describe("Horizontal anchor, source-normalized [0,1]."),
+        y: z.number().min(0).max(1).describe("Vertical anchor, source-normalized [0,1].")
+      }).optional().describe(
+        "Durable scene-space anchor for a behind-subject overlay. Omit to keep the system-placed (or previously set) anchor."
+      )
+    }),
+    metadata: { label: "Update Overlay" },
+    inputExamples: [
+      { input: { id: "abc-123", text: "Updated Title", accentColor: "#6366f1" } },
+      { input: { id: "def-456", startTime: 10, duration: 5, jsxSource: "export default function..." } },
+      { input: { id: "ghi-789", zPlane: "behind-subject", anchor: { x: 0.5, y: 0.4 }, parallax: 0.1 } }
+    ],
+    handler: async (args, capabilities) => {
+      const composition = capabilities.composition.getState().composition;
+      const allOverlays = selectAllOverlays(composition);
+      const existingClip = allOverlays.find((o) => o.id === args.id);
+      if (!existingClip || existingClip.source.kind !== "overlay") {
+        const valid = allOverlays.filter((o) => o.source.kind === "overlay").map((o) => `'${o.id}'`);
+        return {
+          error: `Overlay ${args.id} not found. ` + (valid.length > 0 ? `Overlay clip ids in this composition: ${valid.join(", ")}.` : `This composition has no overlay clips.`)
+        };
+      }
+      const existingSource = existingClip.source;
+      const updates = {};
+      if (args.startTime != null) updates.startTime = args.startTime;
+      if (args.duration != null) updates.duration = args.duration;
+      const existingTemplate = existingSource.primitiveId;
+      if (args.text != null && existingTemplate) {
+        if (getPrimitiveTextParam(existingTemplate) === null) {
+          return { error: `Overlay template "${existingTemplate}" does not accept a text payload.` };
+        }
+      }
+      if (args.subtext != null && existingTemplate) {
+        if (getPrimitiveSubtextParam(existingTemplate) === null) {
+          return { error: `Overlay template "${existingTemplate}" does not accept a subtext payload.` };
+        }
+      }
+      const newParams = {
+        ...existingSource.params,
+        ...args.params ?? {}
+      };
+      if (args.text != null) newParams.text = args.text;
+      if (args.subtext != null) newParams.subtext = args.subtext;
+      if (args.accentColor != null) newParams.accentColor = args.accentColor;
+      if (args.textColor != null) newParams.textColor = args.textColor;
+      if (args.backgroundColor != null) newParams.backgroundColor = args.backgroundColor;
+      if (args.fontFamily != null) newParams.fontFamily = args.fontFamily;
+      if (args.position != null) newParams.position = args.position;
+      if (args.transition != null) newParams.transition = args.transition;
+      if (args.sequenceGroup != null) newParams.sequenceGroup = args.sequenceGroup;
+      const jsxSource = args.jsxSource;
+      let primitiveId = args.primitiveId ?? existingTemplate;
+      if (jsxSource) {
+        newParams.jsxSource = jsxSource;
+        newParams.componentManifest ??= {
+          version: 2,
+          assets: {},
+          graphics: { api: "canvas2d", required: true, accelerationPreference: "software-allowed" },
+          alphaPolicy: "requires-transparency"
+        };
+        primitiveId = "custom";
+      }
+      const newSource = { ...existingSource, primitiveId, params: newParams };
+      if (args.zPlane != null) newSource.zPlane = args.zPlane;
+      if (args.parallax != null) newSource.parallax = args.parallax;
+      if (args.anchor != null) {
+        const a = args.anchor;
+        newSource.anchor = { space: "scene", x: a.x, y: a.y };
+      }
+      updates.source = newSource;
+      capabilities.composition.updateOverlay(args.id, updates);
+      return { success: true, message: `Updated overlay ${args.id}` };
+    }
+  },
+  capture_frames: {
+    name: "capture_frames",
+    description: "Capture rendered video frames at specific frame numbers for visual verification. Returns base64 JPEG images. Call this after creating/updating overlays to verify they look correct.",
+    schema: z.object({
+      frames: z.array(z.coerce.number().int().min(0)).min(1).max(4).describe("Frame numbers to capture (max 4)")
+    }),
+    metadata: { label: "Capture Frames", imageResponse: true, dedupExempt: true },
+    handler: async (args, capabilities) => {
+      if (!capabilities.capture) return { error: "Frame capture not available." };
+      const MAX_RETRIES = 2;
+      let lastErr;
+      for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          if (attempt > 0) {
+            console.info("[compose-role-tools] Retrying capture_frames", {
+              attempt,
+              cause: lastErr instanceof Error ? lastErr.message.slice(0, 300) : String(lastErr).slice(0, 300)
+            });
+            await new Promise((r) => setTimeout(r, 500 * attempt));
+          }
+          return await capabilities.capture.captureFrames(args.frames);
+        } catch (err) {
+          if (err instanceof AgentFixableCaptureError) return { error: err.message };
+          lastErr = err;
+        }
+      }
+      return {
+        error: `capture_frames failed after ${MAX_RETRIES + 1} attempts: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}. You are now BLIND \u2014 you cannot see what you are authoring. Do not keep editing on guesswork; this run will be failed.`
+      };
+    }
+  },
+  score_composition: {
+    name: "score_composition",
+    description: "Score the CURRENT composition against the CueFrame quality rubric (editorial, spatial, brand, caption). Renders the meaningful beats, runs the vision judge, and returns per-criterion scores (0\u201310) plus the single weakest criterion to fix next. This is your OBJECTIVE check on whether the cut is good enough \u2014 use it instead of judging from your own eyes. Call it before finalizing, and after a fix to confirm the score moved.",
+    schema: z.object({}),
+    metadata: { label: "Score Composition", dedupExempt: true },
+    toModelOutput: (result) => ({ type: "text", value: result.slice(0, 1200) }),
+    handler: async (_args, capabilities) => {
+      if (!capabilities.verify) return { error: "Composition scoring not available." };
+      return await capabilities.verify.verify();
+    }
+  },
+  apply_motion_preset: {
+    name: "apply_motion_preset",
+    description: "Apply a vetted motion preset to a STATIC card clip: the approved layout is carried verbatim; only entrance/hold/exit animate. Presets: fade-up (calm default) | slide-in-left | slide-in-right (directional) | scale-pop (punchy stat) | stagger-reveal (enumerations \u2014 needs a [data-stagger] container in the markup). Library overlays already animate \u2014 tune their params/timing with update_overlay instead; custom components already carry their authored motion.",
+    schema: z.object({
+      clipId: z.string().min(1).describe("The card clip to animate (its id in the working composition)."),
+      preset: z.enum(["fade-up", "slide-in-left", "slide-in-right", "scale-pop", "stagger-reveal"]),
+      enterMs: z.number().int().min(80).max(1200).optional().describe("Entrance duration; default 300."),
+      exitMs: z.number().int().min(80).max(1200).optional().describe("Exit duration (completes at clip end); default 300."),
+      staggerMs: z.number().int().min(40).max(400).optional().describe("stagger-reveal only: per-child delay; default 120.")
+    }),
+    metadata: { label: "Apply Motion Preset", dedupExempt: true },
+    handler: async (args, capabilities) => {
+      if (!capabilities.motionPreset) return { error: "Motion presets not available." };
+      return await capabilities.motionPreset.apply(
+        args
+      );
+    }
+  },
+  search_library: {
+    name: "search_library",
+    description: 'Search across all media in the library. Combines transcript text search (fast, exact match) with semantic scene search (CLIP text-to-image similarity). Use for questions like "find clips about pricing" or "find scenes with mountains".',
+    schema: z.object({
+      query: z.string().min(1).describe("Search query \u2014 a word/phrase or a visual concept")
+    }),
+    metadata: { label: "Search Library" },
+    inputExamples: [{ input: { query: "pricing discussion" } }],
+    handler: async (args, capabilities) => {
+      const searchFn = capabilities.resources?.searchLibrary;
+      if (!searchFn) return { error: "Library search not available. Configure a resource provider." };
+      try {
+        const results = await searchFn(args.query);
+        if (!Array.isArray(results)) {
+          return {
+            error: `Library search returned ${results === null ? "null" : typeof results}, not the candidate array this lane expects. The compose capability contract is an array of {mediaId, kind, provider, query, \u2026} \u2014 see composeCapabilities.ts.`
+          };
+        }
+        const candidates = results;
+        if (candidates.length === 0) return "No enrichment candidates available for this clip.";
+        const lines = [
+          `Enrichment candidate pool (${candidates.length} item${candidates.length === 1 ? "" : "s"}, pre-curated by upstream relevance gate):`
+        ];
+        for (const c of candidates) {
+          const score = typeof c.relevanceScore === "number" ? ` (${c.relevanceScore.toFixed(1)}/10)` : "";
+          const dim = c.width && c.height ? ` ${c.width}x${c.height}` : "";
+          const dur = c.duration ? `${c.duration.toFixed(1)}s` : "?s";
+          const reason = c.relevanceReason ? `
+      \u2192 ${c.relevanceReason}` : "";
+          lines.push(`  [${c.mediaId}] ${c.kind}/${c.provider}: "${c.query}" ${dur}${dim}${score}${reason}`);
+        }
+        return lines.join("\n");
+      } catch (err) {
+        return { error: `Library search failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    }
+  },
+  submit_compose_plan: {
+    name: "submit_compose_plan",
+    description: "Submit the FULL compose plan \u2014 framing per beat (frame or trim), pacing cuts, caption style intent, asset requests (resolved from the pool), graphics/hero beats, markers. Call exactly once at the end of planning. The plan is validated and then LOCKED for execution.",
+    schema: ComposePlan,
+    metadata: { label: "Submit Compose Plan" },
+    strict: true,
+    handler: async (args, capabilities) => {
+      if (!capabilities.planSink) {
+        return { error: "submit_compose_plan is only available in the planning phase." };
+      }
+      capabilities.planSink.submit(args);
+      return "Plan received. Planning phase complete \u2014 stop here.";
+    }
+  },
+  amend_compose_plan: {
+    name: "amend_compose_plan",
+    description: "REPAIR the current plan with targeted ops \u2014 you CANNOT resubmit the whole plan in repair mode. Emit ONLY ops for the sections the errors name; every other section is preserved by the system exactly as-is. Ops: framing.set/cuts.set/captions.set/markers.set (replace that whole section), graphics.add|update|remove and assets.add|update|remove (address ONE element by its exact id \u2014 ids are stable addresses; never invent or renumber them). One logical fix per op.",
+    schema: z.object({
+      ops: z.array(z.object({ type: z.string().min(1) }).passthrough()).min(1).max(20).describe(
+        "Amendment ops. The worker validates each op against the canonical PlanOp union and rejects the whole batch on any invalid op (atomic)."
+      )
+    }),
+    metadata: { label: "Amend Compose Plan" },
+    handler: async (args, capabilities) => {
+      if (!capabilities.planSink) {
+        return { error: "amend_compose_plan is only available in the planning phase." };
+      }
+      capabilities.planSink.submit({ __planOps: args.ops });
+      return "Amendment ops received. Repair round complete \u2014 stop here.";
+    }
+  }
+});
+var COMPOSE_ROLE_TOOL_NAMES = Object.keys(COMPOSE_ROLE_TOOLS);
+async function dispatchComposeRoleTool(toolName, args, capabilities, opts) {
+  const entry = COMPOSE_ROLE_TOOLS[toolName];
+  if (!entry) {
+    return {
+      error: `Unknown tool: ${toolName}. This lane serves ${COMPOSE_ROLE_TOOL_NAMES.join(", ")} \u2014 every other verb moved to the curated /v1 surface.`
+    };
+  }
+  const result = entry.schema.safeParse(args);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    return { error: `Invalid tool arguments: ${issues}` };
+  }
+  return entry.handler(result.data, capabilities, opts);
+}
+
+// ../authoring/src/agent/buildTools.ts
+function formatToolResult(name, result) {
+  if (!COMPOSE_ROLE_TOOLS[name]?.metadata.imageResponse) {
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+  if (Array.isArray(result)) {
+    const images = result;
+    return {
+      type: "content",
+      value: images.map((b64) => ({
+        type: "image-data",
+        mediaType: "image/jpeg",
+        data: b64
+      }))
+    };
+  }
+  return typeof result === "string" ? result : JSON.stringify(result);
+}
+var DEDUP_MAX = 3;
+function makeCallKey(name, args) {
+  return `${name}:${canonicalJson(args)}`;
+}
+var APPROVAL_TIMEOUT_MS = 2 * 60 * 1e3;
+function buildToolsFromSchemas(params) {
+  const capabilities = params.capabilities;
+  const toolOpts = {
+    ...params.toolOptions ?? {},
+    ...params.cachedContext ? { cachedContext: params.cachedContext } : {},
+    onProgress: params.onProgress
+  };
+  const recentCalls = /* @__PURE__ */ new Map();
+  const tools = {};
+  for (const [name, schema] of Object.entries(COMPOSE_ROLE_TOOLS)) {
+    if (params.allowedTools && !params.allowedTools.includes(name)) continue;
+    const meta = schema.metadata;
+    const needsApproval = params.approvalRequired?.has(name) ?? false;
+    tools[name] = tool({
+      description: schema.description,
+      inputSchema: schema.schema,
+      execute: async (args) => {
+        const toolCallId = `tc_${crypto.randomUUID().slice(0, 8)}`;
+        if (!meta.dedupExempt) {
+          const callKey = makeCallKey(name, args);
+          const callCount = (recentCalls.get(callKey) ?? 0) + 1;
+          recentCalls.set(callKey, callCount);
+          if (callCount >= DEDUP_MAX) {
+            const msg = `Tool "${name}" called ${callCount} times with identical arguments. This looks like a loop \u2014 try a different approach or different arguments.`;
+            params.onProgress({
+              type: "tool-result",
+              agent: "router",
+              toolName: name,
+              success: false,
+              message: msg,
+              toolCallId,
+              timestamp: Date.now()
+            });
+            return JSON.stringify({ error: msg });
+          }
+        }
+        params.onProgress({
+          type: "tool-call",
+          agent: "router",
+          toolName: name,
+          args,
+          toolCallId,
+          timestamp: Date.now()
+        });
+        if (needsApproval && params.requestApproval) {
+          const approved = await Promise.race([
+            params.requestApproval(toolCallId, name, args),
+            new Promise(
+              (resolve) => setTimeout(() => resolve(false), APPROVAL_TIMEOUT_MS)
+            )
+          ]);
+          if (!approved) {
+            const msg = "User denied this tool call (or approval timed out).";
+            params.onProgress({
+              type: "tool-result",
+              agent: "router",
+              toolName: name,
+              success: false,
+              message: msg,
+              toolCallId,
+              timestamp: Date.now()
+            });
+            return JSON.stringify({ error: msg });
+          }
+        }
+        try {
+          const result = await dispatchComposeRoleTool(name, args, capabilities, toolOpts);
+          params.onProgress({
+            type: "tool-result",
+            agent: "router",
+            toolName: name,
+            success: true,
+            message: typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200),
+            toolCallId,
+            timestamp: Date.now()
+          });
+          return result;
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          params.onProgress({
+            type: "tool-result",
+            agent: "router",
+            toolName: name,
+            success: false,
+            message: errMsg,
+            toolCallId,
+            timestamp: Date.now()
+          });
+          return JSON.stringify({ error: errMsg });
+        }
+      },
+      toModelOutput: ({ output }) => {
+        const formatted = formatToolResult(name, output);
+        return typeof formatted === "string" ? { type: "text", value: formatted } : formatted;
+      }
+    });
+  }
+  return tools;
+}
+var buildDirectorTools = buildToolsFromSchemas;
+var buildPlannerTools = (p) => {
+  const { toolNames = COMPOSE_PLANNER_TOOLS, ...rest } = p;
+  return buildToolsFromSchemas({ ...rest, allowedTools: [...toolNames] });
+};
+
 // ../authoring/src/agent/contextManagement.ts
 import { pruneMessages } from "ai";
 var EVICTED_IMAGE_STUB = "[capture still evicted to save context \u2014 the frame was seen and acted on; re-capture ONLY if you must re-verify pixels]";
@@ -157,16 +662,71 @@ var cachePrepareStep = ({ model, messages }) => ({
   messages: isAnthropicModel(model) ? addCacheControlToLastMessage(messages) : messages
 });
 
+// ../authoring/src/agent/errors.ts
+import { APICallError, TypeValidationError } from "ai";
+var BODY_EXCERPT = 200;
+function providerMessage(responseBody) {
+  if (!responseBody) return void 0;
+  try {
+    const body = JSON.parse(responseBody);
+    const msg = body?.error?.message ?? body?.message;
+    return msg == null ? void 0 : String(msg);
+  } catch {
+    return void 0;
+  }
+}
+function bodyExcerpt(responseBody) {
+  const trimmed = responseBody?.trim();
+  if (!trimmed) return void 0;
+  return trimmed.replace(/\s+/g, " ").slice(0, BODY_EXCERPT);
+}
+function extractProviderError(err) {
+  if (APICallError.isInstance(err)) {
+    const status = err.statusCode;
+    if (status === 401 || status === 403) {
+      return "Authentication failed. Check your API key or gateway configuration in Settings.";
+    }
+    if (status === 429) {
+      return "API rate limit or quota exceeded. Try again later.";
+    }
+    const detail = providerMessage(err.responseBody);
+    if (status === 413 || status === 400) {
+      if (detail) return detail.slice(0, 200);
+    }
+    const where = status === void 0 ? "" : ` (HTTP ${status})`;
+    const evidence = detail ?? bodyExcerpt(err.responseBody);
+    return (evidence ? `${err.message}${where}: ${evidence}` : `${err.message}${where}`).slice(
+      0,
+      300
+    );
+  }
+  if (TypeValidationError.isInstance(err)) {
+    return "Invalid response from AI provider. The provider may be misconfigured or unavailable.";
+  }
+  const raw = err instanceof Error ? err.message : String(err);
+  if (raw.includes("API key not valid")) {
+    return "API key not valid. Check your gateway or provider configuration in Settings.";
+  }
+  return raw.slice(0, 300);
+}
+var ZERO_USAGE = {
+  inputTokens: 0,
+  outputTokens: 0,
+  totalTokens: 0,
+  inputTokenDetails: { noCacheTokens: void 0, cacheReadTokens: void 0, cacheWriteTokens: void 0 },
+  outputTokenDetails: { textTokens: void 0, reasoningTokens: void 0 }
+};
+
 // ../authoring/src/evaluate.ts
 import { generateObject } from "ai";
-import { z } from "zod";
-var CriterionResultSchema = z.object({
-  name: z.string(),
-  passed: z.boolean(),
-  feedback: z.string().optional()
+import { z as z2 } from "zod";
+var CriterionResultSchema = z2.object({
+  name: z2.string(),
+  passed: z2.boolean(),
+  feedback: z2.string().optional()
 });
-var CriteriaEvaluationSchema = z.object({
-  criteria: z.array(CriterionResultSchema)
+var CriteriaEvaluationSchema = z2.object({
+  criteria: z2.array(CriterionResultSchema)
 });
 var CRITERIA_EVALUATOR_PROMPT = `You are a strict QA evaluator. For each criterion you are given, determine whether the work passes or fails.
 
@@ -238,11 +798,11 @@ Above are ${frames.length} captured frames. Use them to evaluate visual criteria
 
 // ../authoring/src/evaluator.ts
 import { generateObject as generateObject2 } from "ai";
-import { z as z2 } from "zod";
-var EvaluationSchema = z2.object({
-  scores: z2.record(z2.string(), z2.number()),
-  critique: z2.string(),
-  evidence: z2.array(z2.string())
+import { z as z3 } from "zod";
+var EvaluationSchema = z3.object({
+  scores: z3.record(z3.string(), z3.number()),
+  critique: z3.string(),
+  evidence: z3.array(z3.string())
 });
 var TIMELINE_RUBRIC = {
   dimensions: [
@@ -944,7 +1504,7 @@ ${body}`;
 
 // ../authoring/src/decomposer.ts
 import { generateObject as generateObject3 } from "ai";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // ../authoring/src/prompts/decomposerPrompt.ts
 var DECOMPOSER_PROMPT = `You decompose video editing tasks into sequential phases.
@@ -977,13 +1537,13 @@ OUTPUT FORMAT (JSON only, no markdown):
 Set evaluationPasses to 1 for timeline edits and scene compositions, 3 for artifacts (content gets more critique passes).`;
 
 // ../authoring/src/decomposer.ts
-var PhaseSchema = z3.object({
-  phases: z3.array(z3.object({
-    name: z3.string(),
-    output: z3.enum(["timeline_edit", "artifact", "scene_composition"]).default("timeline_edit"),
-    description: z3.string(),
-    verificationCriteria: z3.array(z3.string()).default([]),
-    evaluationPasses: z3.number().default(1)
+var PhaseSchema = z4.object({
+  phases: z4.array(z4.object({
+    name: z4.string(),
+    output: z4.enum(["timeline_edit", "artifact", "scene_composition"]).default("timeline_edit"),
+    description: z4.string(),
+    verificationCriteria: z4.array(z4.string()).default([]),
+    evaluationPasses: z4.number().default(1)
   }))
 });
 var COMPLEX_KEYWORDS = /\b(workflow|produce|post-?produce|podcast|episode|batch|multi|series|sequence|blog|show.?notes|thumbnail|description)\b/i;
@@ -1027,177 +1587,63 @@ ${context}`,
   }
 }
 
-// ../authoring/src/motion/shell.ts
-var MOTION_PRESETS = [
-  "fade-up",
-  "slide-in-left",
-  "slide-in-right",
-  "scale-pop",
-  "stagger-reveal"
-];
-var PRESET_FROM = {
-  "fade-up": { dx: 0, dy: 24, scale: 1 },
-  "slide-in-left": { dx: -48, dy: 0, scale: 1 },
-  "slide-in-right": { dx: 48, dy: 0, scale: 1 },
-  "scale-pop": { dx: 0, dy: 0, scale: 0.92 },
-  "stagger-reveal": { dx: 0, dy: 12, scale: 1 }
-};
-var PRESET_SUSTAIN = {
-  "fade-up": { dx: 0, dy: -6, scale: 0.012 },
-  "slide-in-left": { dx: 14, dy: 0, scale: 8e-3 },
-  "slide-in-right": { dx: -14, dy: 0, scale: 8e-3 },
-  "scale-pop": { dx: 0, dy: -4, scale: 0.012 },
-  "stagger-reveal": { dx: 0, dy: -4, scale: 0.01 }
+// ../authoring/src/pipelineTrace.ts
+var DEFAULT_LOGGER = {
+  info: (msg, data) => console.info(`[pipeline-trace] ${msg}`, ...data ? [data] : []),
+  warn: (msg, data) => console.warn(`[pipeline-trace] ${msg}`, ...data ? [data] : []),
+  error: (msg, data) => console.error(`[pipeline-trace] ${msg}`, ...data ? [data] : []),
+  debug: (msg, data) => console.debug(`[pipeline-trace] ${msg}`, ...data ? [data] : [])
 };
-var POP_WOBBLE = { amp: 8e-3, tau: 0.45, hz: 1.8 };
-var STAGGER_BREATHE = { amp: 2, periodS: 3.4, phase: 0.9 };
-var MAX_STAGGER_CHILDREN = 8;
-function generateMotionShell(cardHtml, opts) {
-  if (!cardHtml.trim()) throw new Error("generateMotionShell: empty card markup");
-  const enterMs = opts.enterMs ?? 300;
-  const exitMs = opts.exitMs ?? 300;
-  const staggerMs = opts.staggerMs ?? 120;
-  const from = PRESET_FROM[opts.preset];
-  if (!from) throw new Error(`generateMotionShell: unknown preset '${opts.preset}'`);
-  const sustain = PRESET_SUSTAIN[opts.preset];
-  const tokenVars = cssLayoutVars(opts.tokens, void 0);
-  const staggerBlock = opts.preset === "stagger-reveal" ? `
-  const staggerF = Math.max(1, Math.round((${staggerMs} / 1000) * fps));
-  const staggerRules = Array.from({ length: ${MAX_STAGGER_CHILDREN} }, (_, i) => {
-    const s = enterF + i * staggerF;
-    const o = interpolate(frame, [s, s + enterF], [0, 1], { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
-    const breathe = ${STAGGER_BREATHE.amp} * Math.sin((tSec / ${STAGGER_BREATHE.periodS}) * Math.PI * 2 + i * ${STAGGER_BREATHE.phase});
-    return '[data-stagger] > *:nth-child(' + (i + 1) + ') { opacity: ' + o + '; translate: 0 ' + breathe.toFixed(3) + 'px; }';
-  }).join('\\n');` : "";
-  const staggerStyleEl = opts.preset === "stagger-reveal" ? `<style>{staggerRules}</style>` : "";
-  return `// generated by @cueframe/authoring generateMotionShell \u2014 preset: ${opts.preset}
-import { Easing, interpolate, useCurrentFrame, useVideoConfig } from 'remotion';
-
-export default function CardMotionShell({ durationInFrames, params }) {
-  const frame = useCurrentFrame();
-  const { fps } = useVideoConfig();
-  const CARD_HTML = ${JSON.stringify(cardHtml)};
-  const enterF = Math.max(1, Math.round((${enterMs} / 1000) * fps));
-  const exitF = Math.max(1, Math.round((${exitMs} / 1000) * fps));
-  const enter = interpolate(frame, [0, enterF], [0, 1],
-    { easing: Easing.out(Easing.cubic), extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
-  const exit = interpolate(frame,
-    [Math.max(enterF + 1, durationInFrames - exitF), durationInFrames], [1, 0],
-    { easing: Easing.in(Easing.cubic), extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
-  const opacity = Math.min(enter, exit);
-  const hold = interpolate(frame, [enterF, durationInFrames], [0, 1],
-    { extrapolateLeft: 'clamp', extrapolateRight: 'clamp' });
-  const tSec = Math.max(0, frame - enterF) / fps;
-  const wobble = ${opts.preset === "scale-pop" ? `${POP_WOBBLE.amp} * Math.exp(-tSec / ${POP_WOBBLE.tau}) * Math.sin(tSec * Math.PI * 2 * ${POP_WOBBLE.hz})` : "0"};
-  const dx = ${from.dx} * (1 - enter) + ${sustain.dx} * hold;
-  const dy = ${from.dy} * (1 - enter) + ${sustain.dy} * hold;
-  const scale = ${from.scale} + (1 - ${from.scale}) * enter + ${sustain.scale} * hold + wobble;${staggerBlock}
-  const TOKEN_VARS = ${JSON.stringify(tokenVars)};
-  return (
-    <div style={{ position: 'absolute', inset: 0, ...TOKEN_VARS,
-      opacity, transform: 'translate(' + dx + 'px,' + dy + 'px) scale(' + scale + ')' }}>
-      ${staggerStyleEl}<div style={{ width: '100%', height: '100%' }}
-        dangerouslySetInnerHTML={{ __html: CARD_HTML }} />
-    </div>
-  );
-}
-`;
-}
-
-// ../authoring/src/motion/applyMotionPreset.ts
-var MotionPresetError = class extends Error {
-  constructor(code, message, opIndex) {
-    super(message);
-    this.code = code;
-    this.opIndex = opIndex;
-    this.name = "MotionPresetError";
+var PipelineTrace = class {
+  t0 = performance.now();
+  openSpans = /* @__PURE__ */ new Map();
+  spans = [];
+  toolCallCount = 0;
+  log;
+  constructor(logger) {
+    this.log = logger ?? DEFAULT_LOGGER;
   }
-  code;
-  opIndex;
-};
-function resolveMotionPresetCard(composition, input) {
-  if (!MOTION_PRESETS.includes(input.preset)) {
-    throw new MotionPresetError(
-      "motion_preset_unknown",
-      `unknown motion preset '${input.preset}' \u2014 pick one of: ${MOTION_PRESETS.join(", ")}`
-    );
+  start(name) {
+    this.openSpans.set(name, performance.now());
   }
-  const tracks = composition.tracks ?? [];
-  const sourced = tracks.flatMap((t) => t?.contents ?? []).filter((c) => !!c && typeof c === "object" && "source" in c && "id" in c);
-  const clip = sourced.find((c) => c.id === input.clipId);
-  if (!clip) {
-    const cards = sourced.filter((c) => c.source.kind === "card").map((c) => `'${c.id}'`);
-    throw new MotionPresetError(
-      "motion_preset_target_invalid",
-      `applyMotionPreset: no clip '${input.clipId}' in the composition. ` + (cards.length > 0 ? `Static card clip ids present: ${cards.join(", ")}.` : `No static card clips remain (already shelled or none authored).`)
-    );
+  end(name) {
+    const startMs = this.openSpans.get(name);
+    if (startMs === void 0) return;
+    this.openSpans.delete(name);
+    this.spans.push({ name, startMs, endMs: performance.now() });
   }
-  if (clip.source.kind !== "card" || !clip.source.html) {
-    throw new MotionPresetError(
-      "motion_preset_target_invalid",
-      `applyMotionPreset targets only static card clips \u2014 clip '${input.clipId}' is '${clip.source.kind}'. Library overlays already move (update them directly); components already carry their authored motion.`
-    );
+  recordToolCall() {
+    this.toolCallCount++;
   }
-  return {
-    cardHtml: clip.source.html,
-    ...clip.source.tokens !== void 0 ? { tokens: clip.source.tokens } : {},
-    ...clip.source.zPlane !== void 0 ? { zPlane: clip.source.zPlane } : {}
-  };
-}
-
-// ../authoring/src/motion/materializeMotionPresetOps.ts
-var isMotionPresetOp = (op) => !!op && typeof op === "object" && op.type === "applyMotionPreset";
-var hasMotionPresetOp = (ops) => ops.some(isMotionPresetOp);
-async function materializeMotionPresetOpsCore(composition, ops, deps) {
-  const out = [];
-  let current = composition;
-  for (let i = 0; i < ops.length; i++) {
-    const op = ops[i];
-    if (!isMotionPresetOp(op)) {
-      out.push(op);
-      if (deps.apply) current = deps.apply(current, op);
-      continue;
+  summary() {
+    const totalMs = performance.now() - this.t0;
+    const accounted = this.spans.reduce((sum, s) => sum + (s.endMs - s.startMs), 0);
+    const unaccounted = totalMs - accounted;
+    this.log.info(`Pipeline trace: ${Math.round(totalMs)}ms total, ${this.toolCallCount} tool calls`, {
+      totalMs: Math.round(totalMs),
+      toolCalls: this.toolCallCount
+    });
+    for (const span of this.spans) {
+      const dur = span.endMs - span.startMs;
+      const pct = totalMs > 0 ? (dur / totalMs * 100).toFixed(0) : "0";
+      this.log.info(`  ${span.name.padEnd(24)} ${dur.toFixed(0).padStart(6)}ms  ${pct.padStart(3)}%`);
     }
-    let card;
-    try {
-      card = resolveMotionPresetCard(current, { clipId: op.clipId, preset: op.preset });
-    } catch (err) {
-      if (err instanceof MotionPresetError) err.opIndex = i;
-      throw err;
+    if (unaccounted > 50) {
+      const pct = (unaccounted / totalMs * 100).toFixed(0);
+      this.log.info(`  ${"(unaccounted)".padEnd(24)} ${unaccounted.toFixed(0).padStart(6)}ms  ${pct.padStart(3)}%`);
     }
-    const componentId = `motion-shell-${op.clipId}`;
-    const tsxSource = generateMotionShell(card.cardHtml, {
-      preset: op.preset,
-      ...op.params?.enterMs !== void 0 ? { enterMs: op.params.enterMs } : {},
-      ...op.params?.exitMs !== void 0 ? { exitMs: op.params.exitMs } : {},
-      ...op.params?.staggerMs !== void 0 ? { staggerMs: op.params.staggerMs } : {},
-      ...card.tokens !== void 0 ? { tokens: card.tokens } : {}
-    });
-    const materialized = await deps.sink({
-      componentId,
-      clipId: op.clipId,
-      preset: op.preset,
-      tsxSource,
-      ...card.zPlane !== void 0 ? { zPlane: card.zPlane } : {}
-    });
-    out.push(materialized);
-    if (deps.apply) current = deps.apply(current, materialized);
   }
-  return out;
-}
+};
 export {
   ARTIFACT_RUBRIC,
   Agent,
   AgentFixableCaptureError,
-  CODE_GEN_FEW_SHOT_EXAMPLES,
-  COMPONENT_CONTRACT,
   COMPOSE_MOTION_TOOLS,
   COMPOSE_MOTION_VERIFY_TOOLS,
   COMPOSE_PLANNER_REPAIR_TOOLS,
   COMPOSE_PLANNER_TOOLS,
   COMPOSE_ROLE_TOOLS,
   COMPOSE_ROLE_TOOL_NAMES,
-  DESIGN_QUALITY_RULES,
   EVALUATOR_PROMPT,
   MOTION_PRESETS,
   MotionPresetError,
@@ -1205,7 +1651,6 @@ export {
   PipelineTrace as RequestTrace,
   SceneAuthoringError,
   TIMELINE_RUBRIC,
-  TOOLKIT_REFERENCE,
   ZERO_USAGE,
   buildDirectorContext as buildAgentContext,
   buildDirectorContext,
@@ -1232,7 +1677,6 @@ export {
   getExcludedTools,
   hasMotionPresetOp,
   hasSceneOp,
-  initCodeGenPrompts,
   isMotionPresetOp,
   isSceneOp,
   isSceneShotClip,