@cueframe/kernel 0.0.1

package/dist/authoring.js

@@ -0,0 +1,1295 @@
+import {
+  anthropic,
+  buildFastModel,
+  buildModel,
+  makeLangfuseFetch
+} from "./chunk-DIBOJJMU.js";
+import {
+  PipelineTrace
+} from "./chunk-LD5ZOUFT.js";
+import {
+  CODE_GEN_FEW_SHOT_EXAMPLES,
+  COMPONENT_CONTRACT,
+  DESIGN_QUALITY_RULES,
+  DESIGN_REVIEWER_PROMPT,
+  DESIGN_REVIEWER_TOOLS,
+  EVALUATOR_PROMPT,
+  PLANNING_INSTRUCTIONS,
+  TOOLKIT_REFERENCE,
+  buildExecutionTask,
+  buildPlannerUserMessage,
+  formatPlanSteps,
+  initCodeGenPrompts
+} from "./chunk-M3I5LMAB.js";
+import {
+  ZERO_USAGE,
+  buildDirectorTools,
+  buildPlannerTools,
+  buildToolsFromSchemas,
+  extractProviderError
+} from "./chunk-ELLSET2N.js";
+import {
+  ToolLoopAgent,
+  generateObject,
+  generateText,
+  isStepCount,
+  pruneMessages
+} from "./chunk-7GISRVON.js";
+import "./chunk-KF5ETMKB.js";
+import "./chunk-VIVQHIGZ.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-52AHXNKM.js";
+import {
+  AgentFixableCaptureError,
+  getExcludedTools
+} from "./chunk-JOURGVOR.js";
+import {
+  buildDirectorContext
+} from "./chunk-QLAQHR3L.js";
+import "./chunk-5I7VDCAC.js";
+import "./chunk-NV4I6GJV.js";
+import "./chunk-OIRUO5P7.js";
+import {
+  cssLayoutVars
+} from "./chunk-BRKJKB33.js";
+import "./chunk-V43Y7IE4.js";
+import "./chunk-JF4JJAFP.js";
+import "./chunk-TULRCY6U.js";
+import "./chunk-ATAF24QG.js";
+import "./chunk-W35ZMOXB.js";
+import "./chunk-EA6MYCYW.js";
+import "./chunk-7PA7FGLD.js";
+import "./chunk-KYRDKK2D.js";
+import "./chunk-WREYUH2E.js";
+import "./chunk-37NJ27UU.js";
+import "./chunk-2ESYSVXG.js";
+
+// ../authoring/src/agent/contextManagement.ts
+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]";
+function outputHasMedia(output) {
+  if (!output || typeof output !== "object") return false;
+  const o = output;
+  if (o.type === "content" && Array.isArray(o.value)) {
+    return o.value.some(
+      (p) => p && typeof p === "object" && p.type === "media"
+    );
+  }
+  return false;
+}
+function evictImagesFromMessage(message, pinned) {
+  const msg = message;
+  if (msg.role !== "tool" || !Array.isArray(msg.content)) return message;
+  let changed = false;
+  const content = msg.content.map((part) => {
+    const p = part;
+    if (p?.type === "tool-result" && outputHasMedia(p.output)) {
+      if (pinned && p.toolName && pinned.has(p.toolName)) return part;
+      changed = true;
+      return { ...p, output: { type: "text", value: EVICTED_IMAGE_STUB } };
+    }
+    return part;
+  });
+  return changed ? { ...msg, content } : message;
+}
+function buildPrepareStep(policy) {
+  const keep = Math.max(1, Math.floor(policy.keepRecentToolMessages ?? 2));
+  if (policy.evictImagesOnly) {
+    const pinned = policy.pinnedTools?.length ? new Set(policy.pinnedTools) : void 0;
+    return ({ messages }) => {
+      const cutoff = Math.max(0, messages.length - keep);
+      const withStubs = messages.map((m, i) => i < cutoff ? evictImagesFromMessage(m, pinned) : m);
+      return {
+        messages: pruneMessages({
+          messages: withStubs,
+          // Effectively "never" — tool calls/results are managed above.
+          toolCalls: `before-last-${99999}-messages`,
+          reasoning: "before-last-message",
+          emptyMessages: "remove"
+        })
+      };
+    };
+  }
+  const toolCalls = `before-last-${keep}-messages`;
+  return ({ messages }) => ({
+    messages: pruneMessages({
+      messages,
+      toolCalls,
+      // Coupled to tool-call pruning, never 'none': see pruneReasoning above —
+      // older turns lose thinking WHOLESALE (valid) instead of keeping a
+      // signed thinking block on a message whose tool_use was pruned (400).
+      reasoning: "before-last-message",
+      emptyMessages: "remove"
+    })
+  });
+}
+
+// ../authoring/src/agent/promptCache.ts
+function isAnthropicModel(model) {
+  if (typeof model === "string") {
+    return model.includes("anthropic") || model.includes("claude");
+  }
+  return model.provider.includes("anthropic") || model.modelId.includes("anthropic") || model.modelId.includes("claude");
+}
+function addCacheControlToLastMessage(messages) {
+  if (messages.length === 0) return messages;
+  return messages.map(
+    (message, i) => i === messages.length - 1 ? {
+      ...message,
+      providerOptions: {
+        ...message.providerOptions,
+        anthropic: {
+          ...message.providerOptions?.anthropic ?? {},
+          cacheControl: { type: "ephemeral" }
+        }
+      }
+    } : message
+  );
+}
+var cachePrepareStep = ({ model, messages }) => ({
+  messages: isAnthropicModel(model) ? addCacheControlToLastMessage(messages) : messages
+});
+
+// ../authoring/src/evaluate.ts
+import { z } from "zod";
+var CriterionResultSchema = z.object({
+  name: z.string(),
+  passed: z.boolean(),
+  feedback: z.string().optional()
+});
+var CriteriaEvaluationSchema = z.object({
+  criteria: z.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.
+
+RULES:
+- Evaluate each criterion independently.
+- "Pass" means the criterion is clearly met \u2014 not "close enough".
+- If something is ambiguous, it fails. Err on the side of strictness.
+- When you fail a criterion, provide specific, actionable feedback explaining what's wrong and how to fix it.
+- When you pass a criterion, feedback is optional but can note what was done well.
+- Base your evaluation only on the evidence provided (text, state JSON, or images).
+
+OUTPUT: Return a JSON object with a "criteria" array containing one entry per criterion.`;
+async function evaluate(options) {
+  const { model, task, criteria, compositionState, artifact, frames } = options;
+  const criteriaList = Object.entries(criteria).map(([name, desc], i) => `${i + 1}. ${name}: ${desc}`).join("\n");
+  const contentParts = [];
+  let mainText = `TASK: ${task}
+
+CRITERIA TO EVALUATE:
+${criteriaList}`;
+  if (compositionState) {
+    mainText += `
+
+COMPOSITION STATE:
+${compositionState}`;
+  }
+  if (artifact) {
+    mainText += `
+
+ARTIFACT:
+${artifact}`;
+  }
+  contentParts.push({ type: "text", text: mainText });
+  if (frames?.length) {
+    for (const frame of frames) {
+      contentParts.push({ type: "image", image: frame });
+    }
+    contentParts.push({
+      type: "text",
+      text: `
+Above are ${frames.length} captured frames. Use them to evaluate visual criteria.`
+    });
+  }
+  const { object } = await generateObject({
+    model,
+    schema: CriteriaEvaluationSchema,
+    instructions: CRITERIA_EVALUATOR_PROMPT,
+    messages: [{ role: "user", content: contentParts }],
+    // One verbose feedback string per criterion; an 8-9 criterion evaluation
+    // runs ~2.5-4k tokens. A tighter cap truncates the JSON mid-string.
+    maxOutputTokens: 8e3
+  });
+  const criterionNames = Object.keys(criteria);
+  const resultMap = new Map(object.criteria.map((c) => [c.name, c]));
+  const mappedCriteria = criterionNames.map((name) => {
+    const result = resultMap.get(name);
+    return {
+      name,
+      passed: result?.passed ?? false,
+      ...result?.feedback && { feedback: result.feedback }
+    };
+  });
+  const allPassed = mappedCriteria.every((c) => c.passed);
+  return {
+    passed: allPassed,
+    criteria: mappedCriteria,
+    bestAttempt: 1
+    // Caller manages bestAttempt tracking across retries
+  };
+}
+
+// ../authoring/src/evaluator.ts
+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())
+});
+var TIMELINE_RUBRIC = {
+  dimensions: [
+    { name: "correctness", weight: 0.25, description: "Are all requested changes actually applied? Nothing missing?" },
+    { name: "precision", weight: 0.2, description: "Are timings, positions, and durations accurate?" },
+    { name: "design_quality", weight: 0.25, description: "Is the visual design professional? Layered composition, choreographed timing, not just centered text?" },
+    { name: "completeness", weight: 0.15, description: "Were all parts of the request addressed?" },
+    { name: "craft", weight: 0.15, description: "Spring physics, staggered entrances, exit choreography, accent elements?" }
+  ],
+  passThreshold: 6
+};
+var ARTIFACT_RUBRIC = {
+  dimensions: [
+    { name: "accuracy", weight: 0.25, description: "Is the content factually correct and relevant?" },
+    { name: "format", weight: 0.2, description: "Does it match the requested format (markdown, platform-specific, etc.)?" },
+    { name: "quality", weight: 0.25, description: "Is the writing quality professional?" },
+    { name: "audience_fit", weight: 0.15, description: "Is it appropriate for the target platform/audience?" },
+    { name: "completeness", weight: 0.15, description: "Are all requested sections/elements present?" }
+  ],
+  passThreshold: 6
+};
+function computeWeightedScore(scores, dimensions) {
+  return dimensions.reduce((sum, d) => {
+    return sum + (scores[d.name] ?? 0) * d.weight;
+  }, 0);
+}
+function buildDimensionsText(dimensions) {
+  return dimensions.map((d) => `- ${d.name} (weight: ${d.weight}): ${d.description}`).join("\n");
+}
+function buildCriteriaText(verificationCriteria) {
+  if (verificationCriteria.length === 0) return "";
+  return `
+
+VERIFICATION CRITERIA (each must be met to pass):
+${verificationCriteria.map((c, i) => `${i + 1}. ${c}`).join("\n")}`;
+}
+function toEvaluationResult(obj, rubric) {
+  const weightedScore = computeWeightedScore(obj.scores, rubric.dimensions);
+  return {
+    scores: obj.scores,
+    weightedScore,
+    passed: weightedScore >= rubric.passThreshold,
+    critique: obj.critique,
+    evidence: obj.evidence
+  };
+}
+async function evaluateArtifact(model, artifact, task, rubric, verificationCriteria) {
+  const dimensionsText = buildDimensionsText(rubric.dimensions);
+  const criteriaText = buildCriteriaText(verificationCriteria);
+  const { object } = await generateObject({
+    model,
+    schema: EvaluationSchema,
+    instructions: EVALUATOR_PROMPT,
+    prompt: `TASK: ${task}
+
+DIMENSIONS TO SCORE:
+${dimensionsText}${criteriaText}
+
+ARTIFACT TO EVALUATE:
+${artifact}`,
+    // critique + evidence run long; a tighter cap truncates the JSON mid-string.
+    maxOutputTokens: 8e3
+  });
+  return toEvaluationResult(object, rubric);
+}
+async function evaluateTimeline(model, task, rubric, verificationCriteria, compositionContext, capturedFrames) {
+  const dimensionsText = buildDimensionsText(rubric.dimensions);
+  const criteriaText = buildCriteriaText(verificationCriteria);
+  const contentParts = [
+    { type: "text", text: `TASK: ${task}
+
+DIMENSIONS TO SCORE:
+${dimensionsText}${criteriaText}
+
+COMPOSITION STATE:
+${compositionContext}` }
+  ];
+  if (capturedFrames?.length) {
+    for (const frame of capturedFrames) {
+      contentParts.push({ type: "image", image: frame });
+    }
+    contentParts.push({ type: "text", text: `
+
+Above are ${capturedFrames.length} captured frames. Inspect for visual quality, positioning, and timing.` });
+  }
+  const { object } = await generateObject({
+    model,
+    schema: EvaluationSchema,
+    instructions: EVALUATOR_PROMPT,
+    messages: [{ role: "user", content: contentParts }],
+    // critique + evidence run long; a tighter cap truncates the JSON mid-string.
+    maxOutputTokens: 8e3
+  });
+  return toEvaluationResult(object, rubric);
+}
+
+// ../authoring/src/agent.ts
+var HARD_TIMEOUT_MS = 30 * 60 * 1e3;
+var STEP_TIMEOUT_MS = 5 * 60 * 1e3;
+function reserveFinalStep(base, maxSteps, finalStepTools, toolNames) {
+  const allowed = finalStepTools.filter((t) => toolNames.includes(t));
+  return async (opts) => {
+    const prepared = await base(opts);
+    if (opts.stepNumber < maxSteps - 1) return prepared;
+    return { ...prepared, activeTools: allowed };
+  };
+}
+function infraErrorFromSteps(steps) {
+  for (const step of steps) {
+    const content = step.content ?? [];
+    for (const part of content) {
+      const p = part;
+      if (p.type !== "tool-error") continue;
+      const e = p.error;
+      if (e instanceof Error && e.name === "InfraToolError" && e.infra === true) {
+        return e;
+      }
+    }
+  }
+  return null;
+}
+var Agent = class {
+  config;
+  capabilities;
+  messages = [];
+  excludedTools;
+  log;
+  /** Monotonic step index for onStepMetrics; reset per run(). */
+  stepCounter = 0;
+  constructor(config) {
+    this.config = config;
+    this.capabilities = config.capabilities;
+    this.excludedTools = config.capabilities ? getExcludedTools(config.capabilities) : /* @__PURE__ */ new Set();
+    this.log = config.logger ?? {
+      info: () => {
+      },
+      warn: () => {
+      },
+      error: () => {
+      },
+      debug: () => {
+      }
+    };
+  }
+  /** Reset conversation history (new session). */
+  reset() {
+    this.messages = [];
+  }
+  /**
+   * Run the agent with a prompt.
+   *
+   * Without criteria/rubric: single generation pass.
+   * With criteria + maxAttempts > 1: generate → evaluate → refine loop (criteria mode).
+   * With rubric + maxAttempts > 1: generate → evaluate → refine loop (rubric mode).
+   */
+  async run(prompt, opts = {}) {
+    this.stepCounter = 0;
+    const { criteria, rubric, maxAttempts = 1 } = opts;
+    const hasCriteria = criteria && Object.keys(criteria).length > 0;
+    const hasRubric = !!rubric;
+    const needsEvaluation = (hasCriteria || hasRubric) && maxAttempts > 1;
+    if (!needsEvaluation) {
+      return this.executeOnce(prompt, opts);
+    }
+    if (hasRubric) {
+      return this.runWithRubric(prompt, opts);
+    }
+    return this.runWithCriteria(prompt, opts);
+  }
+  // ── Quality loop: criteria mode (pass/fail per criterion) ──
+  async runWithCriteria(prompt, opts) {
+    const { criteria, maxAttempts = 1 } = opts;
+    let bestResult;
+    let bestScore = -1;
+    let totalUsage = { ...ZERO_USAGE };
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const currentPrompt = attempt === 1 ? prompt : this.buildRefinementPrompt(prompt, bestResult.evaluation, criteria);
+      const result = await this.executeOnce(currentPrompt, opts);
+      totalUsage = addUsage(totalUsage, result.usage);
+      if (!result.success) {
+        return { ...result, attempts: attempt, usage: totalUsage };
+      }
+      let evaluation;
+      try {
+        evaluation = await this.evaluateResult(result, prompt, criteria, opts);
+      } catch (err) {
+        this.log.warn?.("Evaluator failed; accepting attempt without grading", {
+          attempt,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return { ...result, attempts: attempt, usage: totalUsage };
+      }
+      const score = evaluation.criteria.filter((c) => c.passed).length;
+      if (score > bestScore) {
+        bestScore = score;
+        bestResult = {
+          ...result,
+          evaluation: { ...evaluation, bestAttempt: attempt },
+          attempts: attempt,
+          usage: totalUsage
+        };
+      }
+      this.config.hooks?.afterEvaluate?.(criteria, evaluation);
+      if (evaluation.passed) {
+        return {
+          ...result,
+          evaluation: { ...evaluation, bestAttempt: attempt },
+          attempts: attempt,
+          usage: totalUsage,
+          success: true
+        };
+      }
+      this.log.info?.("Evaluation failed, retrying", {
+        attempt,
+        maxAttempts,
+        passedCriteria: score,
+        totalCriteria: evaluation.criteria.length
+      });
+    }
+    return bestResult;
+  }
+  // ── Quality loop: rubric mode (weighted numeric scoring) ──
+  async runWithRubric(prompt, opts) {
+    const { rubric, verificationCriteria = [], maxAttempts = 1 } = opts;
+    let bestResult;
+    let bestScore = -1;
+    let totalUsage = { ...ZERO_USAGE };
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      const currentPrompt = attempt === 1 ? prompt : this.buildRubricRefinementPrompt(prompt, bestResult.rubricEvaluation);
+      const result = await this.executeOnce(currentPrompt, opts);
+      totalUsage = addUsage(totalUsage, result.usage);
+      if (!result.success) {
+        return { ...result, attempts: attempt, usage: totalUsage };
+      }
+      let evaluation;
+      try {
+        evaluation = await this.evaluateWithRubric(result, prompt, rubric, verificationCriteria, opts);
+      } catch (err) {
+        this.log.warn?.("Rubric evaluator failed; accepting attempt without grading", {
+          attempt,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return { ...result, attempts: attempt, usage: totalUsage };
+      }
+      if (evaluation.weightedScore > bestScore) {
+        bestScore = evaluation.weightedScore;
+        bestResult = {
+          ...result,
+          rubricEvaluation: evaluation,
+          attempts: attempt,
+          usage: totalUsage
+        };
+      }
+      if (evaluation.passed) {
+        return {
+          ...result,
+          rubricEvaluation: evaluation,
+          attempts: attempt,
+          usage: totalUsage,
+          success: true
+        };
+      }
+      this.log.info?.("Rubric evaluation failed, retrying", {
+        attempt,
+        maxAttempts,
+        weightedScore: evaluation.weightedScore,
+        threshold: rubric.passThreshold
+      });
+    }
+    return bestResult;
+  }
+  // ── Private: single execution pass ──
+  async executeOnce(prompt, opts) {
+    this.messages.push({ role: "user", content: prompt });
+    const hasTools = !!this.capabilities;
+    if (!hasTools) {
+      return this.executeText(prompt, opts);
+    }
+    return this.executeWithTools(prompt, opts);
+  }
+  // ── Text-only execution (no capabilities) ──
+  async executeText(_prompt, opts) {
+    try {
+      const cacheBreakpoint = {
+        providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } }
+      };
+      const result = await generateText({
+        model: this.config.model,
+        instructions: {
+          role: "system",
+          content: this.config.systemPrompt,
+          ...cacheBreakpoint
+        },
+        messages: this.messages.map((m, i) => ({
+          role: m.role,
+          content: m.content,
+          ...i === 0 ? cacheBreakpoint : {}
+        })),
+        abortSignal: opts.abortSignal
+      });
+      const text = result.text;
+      if (text) {
+        this.messages.push({ role: "assistant", content: text });
+      }
+      return {
+        success: true,
+        text,
+        attempts: 1,
+        usage: result.usage
+      };
+    } catch (err) {
+      if (opts.abortSignal?.aborted) {
+        const reason = err instanceof Error ? err.message : "Cancelled.";
+        return { success: false, text: reason, attempts: 1, usage: ZERO_USAGE };
+      }
+      const errMsg = extractProviderError(err);
+      this.log.error?.("Agent text generation failed", { error: errMsg });
+      return { success: false, text: errMsg, attempts: 1, usage: ZERO_USAGE };
+    }
+  }
+  // ── Tool-based execution ──
+  async executeWithTools(_prompt, opts) {
+    const capabilities = this.capabilities;
+    const context = buildDirectorContext(capabilities, { maxChars: 32e3 });
+    const contextJson = JSON.stringify(context, null, 2);
+    const system = `${this.config.systemPrompt}
+
+## Current Context
+
+\`\`\`json
+${contextJson}
+\`\`\``;
+    const configTools = this.config.allowedTools;
+    if (!opts.tools && !configTools && this.config.buildToolSet) {
+      throw new Error(
+        "Agent: `buildToolSet` was provided without `allowedTools` (and run() named no tools). The injected factory builds a different tool vocabulary, so the in-process compose-role tool list is not a valid default for it \u2014 state the tool names the factory should build."
+      );
+    }
+    const allTools = configTools ? configTools.filter((t) => !this.excludedTools.has(t)) : COMPOSE_ROLE_TOOL_NAMES.filter((t) => !this.excludedTools.has(t));
+    const allowedTools = opts.tools ?? allTools;
+    const onProgress = () => {
+    };
+    const beforeHook = this.config.hooks?.beforeToolCall;
+    const afterHook = this.config.hooks?.afterToolCall;
+    const tools = this.config.buildToolSet ? this.config.buildToolSet({ allowedTools, onProgress }) : buildDirectorTools({
+      capabilities,
+      allowedTools,
+      onProgress,
+      cachedContext: context
+    });
+    const wrappedTools = {
+      ...this.wrapToolsWithHooks(tools, beforeHook, afterHook),
+      ...this.config.extraTools ?? {}
+    };
+    const maxSteps = this.config.maxSteps ?? 20;
+    const maxOutputTokens = this.config.maxOutputTokens ?? 16e3;
+    const agent = new ToolLoopAgent({
+      model: this.config.model,
+      maxOutputTokens,
+      // Config uses a structural per-provider record (the nominal
+      // ProviderOptions type isn't re-exported by every ai@6 minor); derive
+      // the SDK's own type from the constructor so the cast tracks upgrades.
+      ...this.config.providerOptions ? {
+        providerOptions: this.config.providerOptions
+      } : {},
+      instructions: {
+        role: "system",
+        content: system,
+        providerOptions: {
+          anthropic: { cacheControl: { type: "ephemeral" } }
+        }
+      },
+      tools: wrappedTools,
+      // B6: halt on an infra-sentinel tool-error step (second condition) — the
+      // model cannot fix a dead scratch/session, so further steps are waste.
+      stopWhen: [
+        isStepCount(maxSteps),
+        ({ steps }) => infraErrorFromSteps(steps) !== null
+      ],
+      // Observability: log each step's tool calls so the agent's craft
+      // behaviour — which tools it invokes vs SKIPS — is visible in the worker
+      // logs instead of a ~100s black box between phases. Names only (args are
+      // verbose); enough to see the tool sequence (e.g. did it call
+      // set_crop_intents / enable_captions_behind_speaker / capture_frames).
+      onStepEnd: (step) => {
+        const names = (step.toolCalls ?? []).map((t) => t.toolName);
+        this.log.info(`[agent] step tools=[${names.join(", ") || "none"}] finish=${step.finishReason ?? "?"}`);
+        const sink = this.config.hooks?.onStepMetrics;
+        if (sink) {
+          const argChars = (step.toolCalls ?? []).reduce(
+            (n, t) => n + JSON.stringify(t.input ?? "").length,
+            0
+          );
+          const anth = step.providerMetadata?.anthropic ?? {};
+          const num = (v) => typeof v === "number" ? v : void 0;
+          sink({
+            stepIndex: this.stepCounter++,
+            toolNames: names,
+            visibleChars: (step.text?.length ?? 0) + argChars,
+            outputTokens: step.usage?.outputTokens,
+            inputTokens: step.usage?.inputTokens,
+            cacheReadTokens: step.usage?.cachedInputTokens ?? num(anth["cacheReadInputTokens"]),
+            cacheWriteTokens: num(anth["cacheCreationInputTokens"]),
+            reasoningTokens: step.usage?.reasoningTokens,
+            ...step.finishReason ? { finishReason: step.finishReason } : {}
+          });
+        }
+      },
+      // Context management: evict stale tool content between steps so a long
+      // tool-heavy run (accumulating tool-results + base64 capture images)
+      // stays under the model's window. Off unless the caller sets a policy.
+      // The moving cache breakpoint applies only when eviction is OFF: the
+      // sliding prune window rewrites messages BEFORE the prior step's
+      // breakpoint each step, so stamped tail entries would be written at
+      // 1.25x and never read back — strictly worse than no stamp. (Possible
+      // follow-up: stamp the eviction boundary instead, whose pruned prefix
+      // is stable step-over-step.) See promptCache.ts for why the
+      // system-only breakpoint leaves image tool-results uncached.
+      prepareStep: this.config.finalStepTools ? reserveFinalStep(
+        this.config.contextManagement ? buildPrepareStep(this.config.contextManagement) : cachePrepareStep,
+        maxSteps,
+        this.config.finalStepTools,
+        Object.keys(wrappedTools)
+      ) : this.config.contextManagement ? buildPrepareStep(this.config.contextManagement) : cachePrepareStep
+    });
+    try {
+      const messages = this.messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      }));
+      if (opts.headless !== false) {
+        const result2 = await agent.generate({
+          messages,
+          abortSignal: opts.abortSignal,
+          timeout: { totalMs: HARD_TIMEOUT_MS, stepMs: STEP_TIMEOUT_MS }
+        });
+        {
+          const infra = infraErrorFromSteps(
+            result2.steps ?? []
+          );
+          if (infra) throw infra;
+        }
+        if (result2.text) {
+          this.messages.push({ role: "assistant", content: result2.text });
+        }
+        return {
+          success: true,
+          text: result2.text,
+          attempts: 1,
+          usage: result2.totalUsage
+        };
+      }
+      const result = await agent.stream({
+        messages,
+        abortSignal: opts.abortSignal,
+        timeout: { totalMs: HARD_TIMEOUT_MS, stepMs: STEP_TIMEOUT_MS }
+      });
+      for await (const _chunk of result.textStream) {
+        if (opts.abortSignal?.aborted) break;
+      }
+      const [finalText, totalUsage] = await Promise.all([result.text, result.totalUsage]);
+      {
+        const steps = await result.steps?.catch(() => []);
+        const infra = infraErrorFromSteps(steps ?? []);
+        if (infra) throw infra;
+      }
+      if (finalText) {
+        this.messages.push({ role: "assistant", content: finalText });
+      }
+      return {
+        success: true,
+        text: finalText,
+        attempts: 1,
+        usage: totalUsage
+      };
+    } catch (err) {
+      if (opts.abortSignal?.aborted) {
+        const reason = err instanceof Error ? err.message : "Cancelled.";
+        return { success: false, text: reason, attempts: 1, usage: ZERO_USAGE };
+      }
+      if (err instanceof Error && err.name === "InfraToolError" && err.infra === true) {
+        throw err;
+      }
+      const errMsg = extractProviderError(err);
+      this.log.error?.("Agent tool execution failed", { error: errMsg });
+      return { success: false, text: errMsg, attempts: 1, usage: ZERO_USAGE };
+    }
+  }
+  // ── Hook wiring ──
+  wrapToolsWithHooks(tools, beforeHook, afterHook) {
+    if (!beforeHook && !afterHook) return tools;
+    const wrapped = {};
+    for (const [name, toolDef] of Object.entries(tools)) {
+      const t = toolDef;
+      const origExecute = t.execute;
+      if (!origExecute) {
+        wrapped[name] = t;
+        continue;
+      }
+      wrapped[name] = {
+        ...t,
+        execute: async (args) => {
+          if (beforeHook) {
+            const allowed = await Promise.resolve(beforeHook(name, args));
+            if (!allowed) {
+              const blocked = JSON.stringify({ error: `Tool call "${name}" blocked by beforeToolCall hook.` });
+              afterHook?.(name, { toolName: name, success: false, message: "Blocked by hook" });
+              return blocked;
+            }
+          }
+          const t0 = Date.now();
+          const result = await origExecute(args);
+          if (afterHook) {
+            const resultStr = typeof result === "string" ? result : JSON.stringify(result);
+            const isError = resultStr.includes('"error"');
+            afterHook(name, {
+              toolName: name,
+              success: !isError,
+              message: typeof result === "string" ? result.slice(0, 200) : JSON.stringify(result).slice(0, 200),
+              durationMs: Date.now() - t0,
+              argsBytes: JSON.stringify(args ?? {}).length,
+              resultBytes: resultStr.length
+            });
+          }
+          return result;
+        }
+      };
+    }
+    return wrapped;
+  }
+  // ── Evaluation ──
+  async evaluateResult(result, task, criteria, _opts) {
+    const evalModel = this.config.evaluationModel ?? this.config.model;
+    const capabilities = this.capabilities;
+    if (capabilities?.capture) {
+      const context = buildDirectorContext(capabilities, { maxChars: 32e3 });
+      const duration = context.timelineDuration ?? 0;
+      const frameTimes = duration > 0 ? [duration * 0.25, duration * 0.5, duration * 0.75] : [0];
+      try {
+        const frames = await capabilities.capture.captureFrames(frameTimes);
+        return evaluate({
+          model: evalModel,
+          task,
+          criteria,
+          compositionState: JSON.stringify(context, null, 2),
+          frames
+        });
+      } catch {
+        return evaluate({
+          model: evalModel,
+          task,
+          criteria,
+          compositionState: JSON.stringify(context, null, 2)
+        });
+      }
+    }
+    if (capabilities) {
+      const context = buildDirectorContext(capabilities, { maxChars: 32e3 });
+      return evaluate({
+        model: evalModel,
+        task,
+        criteria,
+        compositionState: JSON.stringify(context, null, 2)
+      });
+    }
+    return evaluate({
+      model: evalModel,
+      task,
+      criteria,
+      artifact: result.text
+    });
+  }
+  // ── Rubric-based evaluation ──
+  async evaluateWithRubric(result, task, rubric, verificationCriteria, _opts) {
+    const evalModel = this.config.evaluationModel ?? this.config.model;
+    const capabilities = this.capabilities;
+    if (capabilities?.composition) {
+      const context = buildDirectorContext(capabilities, { maxChars: 32e3 });
+      const compositionContext = JSON.stringify(context, null, 2);
+      let capturedFrames;
+      if (capabilities.capture) {
+        const duration = context.timelineDuration ?? 0;
+        const frameTimes = duration > 0 ? [duration * 0.25, duration * 0.5, duration * 0.75] : [0];
+        try {
+          capturedFrames = await capabilities.capture.captureFrames(frameTimes);
+        } catch {
+        }
+      }
+      return evaluateTimeline(evalModel, task, rubric, verificationCriteria, compositionContext, capturedFrames);
+    }
+    return evaluateArtifact(evalModel, result.text ?? "", task, rubric, verificationCriteria);
+  }
+  // ── Refinement prompts ──
+  buildRefinementPrompt(originalTask, evaluation, criteria) {
+    const failedCriteria = evaluation.criteria.filter((c) => !c.passed).map((c) => {
+      const desc = criteria[c.name] ?? "";
+      return `- ${c.name}: ${desc}${c.feedback ? `
+  Feedback: ${c.feedback}` : ""}`;
+    }).join("\n");
+    return `The previous attempt did not meet all quality criteria.
+
+ORIGINAL TASK: ${originalTask}
+
+FAILED CRITERIA:
+${failedCriteria}
+
+Please fix the issues described above. Focus only on the failed criteria \u2014 do not undo work that already passed.`;
+  }
+  buildRubricRefinementPrompt(originalTask, evaluation) {
+    const scoreLines = Object.entries(evaluation.scores).map(([dim, score]) => `- ${dim}: ${score}/10`).join("\n");
+    return `The previous attempt scored ${evaluation.weightedScore.toFixed(1)}/10 (threshold: pass requires higher).
+
+ORIGINAL TASK: ${originalTask}
+
+SCORES:
+${scoreLines}
+
+CRITIQUE: ${evaluation.critique}
+
+EVIDENCE:
+${evaluation.evidence.map((e) => `- ${e}`).join("\n")}
+
+Please address the critique above. Focus on the lowest-scoring dimensions.`;
+  }
+};
+function addUsage(a, b) {
+  return {
+    inputTokens: (a.inputTokens ?? 0) + (b.inputTokens ?? 0),
+    outputTokens: (a.outputTokens ?? 0) + (b.outputTokens ?? 0),
+    totalTokens: (a.totalTokens ?? 0) + (b.totalTokens ?? 0),
+    inputTokenDetails: a.inputTokenDetails,
+    outputTokenDetails: a.outputTokenDetails
+  };
+}
+
+// ../authoring/src/agent/memoryTool.ts
+var MAX_MEMORY_CHARS = 16e3;
+var ROOT = "/memories";
+function totalChars(store) {
+  let n = 0;
+  for (const [p, c] of store) n += p.length + c.length;
+  return n;
+}
+function assertPath(path) {
+  if (path !== ROOT && !path.startsWith(ROOT + "/")) {
+    throw new Error(`Invalid path "${path}" \u2014 all memory lives under ${ROOT}/`);
+  }
+  return path;
+}
+function createAgentMemory(seed) {
+  const store = new Map(Object.entries(seed ?? {}));
+  const view = (path, range) => {
+    if (path === ROOT || path === ROOT + "/") {
+      if (store.size === 0) return `${ROOT}/ is empty \u2014 no notes from a previous attempt.`;
+      return [...store.keys()].sort().map((p) => `${p} (${store.get(p).length} chars)`).join("\n");
+    }
+    const content = store.get(path);
+    if (content === void 0) throw new Error(`File not found: ${path}`);
+    if (!range) return content;
+    const lines = content.split("\n");
+    const [from, to] = range;
+    return lines.slice(Math.max(0, from - 1), to).join("\n");
+  };
+  const write = (path, content) => {
+    const next = new Map(store);
+    next.set(path, content);
+    if (totalChars(next) > MAX_MEMORY_CHARS) {
+      throw new Error(
+        `Memory budget exceeded (${MAX_MEMORY_CHARS} chars total) \u2014 condense your notes: keep decisions and what worked, drop transcripts.`
+      );
+    }
+    store.set(path, content);
+    return `OK: ${path} (${content.length} chars)`;
+  };
+  const execute = async (input) => {
+    try {
+      switch (input.command) {
+        case "view":
+          return view(assertPath(input.path ?? ROOT), input.view_range);
+        case "create":
+          return write(assertPath(input.path), input.file_text ?? "");
+        case "str_replace": {
+          const path = assertPath(input.path);
+          const content = store.get(path);
+          if (content === void 0) throw new Error(`File not found: ${path}`);
+          const occurrences = content.split(input.old_str).length - 1;
+          if (occurrences === 0) throw new Error(`old_str not found in ${path}`);
+          if (occurrences > 1) throw new Error(`old_str appears ${occurrences} times in ${path} \u2014 must be unique`);
+          return write(path, content.replace(input.old_str, input.new_str ?? ""));
+        }
+        case "insert": {
+          const path = assertPath(input.path);
+          const content = store.get(path);
+          if (content === void 0) throw new Error(`File not found: ${path}`);
+          const lines = content.split("\n");
+          const at = Math.max(0, Math.min(input.insert_line ?? 0, lines.length));
+          lines.splice(at, 0, input.insert_text ?? "");
+          return write(path, lines.join("\n"));
+        }
+        case "delete": {
+          const path = assertPath(input.path);
+          if (path === ROOT) {
+            store.clear();
+            return `OK: cleared ${ROOT}/`;
+          }
+          if (!store.delete(path)) throw new Error(`File not found: ${path}`);
+          return `OK: deleted ${path}`;
+        }
+        case "rename": {
+          const from = assertPath(input.old_path);
+          const to = assertPath(input.new_path);
+          const content = store.get(from);
+          if (content === void 0) throw new Error(`File not found: ${from}`);
+          store.delete(from);
+          store.set(to, content);
+          return `OK: ${from} \u2192 ${to}`;
+        }
+        default:
+          throw new Error(`Unknown memory command: ${input.command}`);
+      }
+    } catch (err) {
+      return `Error: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  };
+  return {
+    tools: { memory: anthropic.tools.memory_20250818({ execute }) },
+    snapshot: () => Object.fromEntries(store)
+  };
+}
+
+// ../authoring/src/scope.ts
+function renderSkillContent(name, body) {
+  return `
+
+## Craft constraints \u2014 ${name} (MANDATORY: these are graded by the critic panel)
+${body}`;
+}
+
+// ../authoring/src/decomposer.ts
+import { z as z3 } from "zod";
+
+// ../authoring/src/prompts/decomposerPrompt.ts
+var DECOMPOSER_PROMPT = `You decompose video editing tasks into sequential phases.
+
+Each phase is one of:
+- timeline_edit: modifies the video composition (add overlays, trim clips, etc.)
+- artifact: produces text output (blog post, show notes, descriptions)
+- scene_composition: creates a new composition from scratch using scenes (documentary, slideshow, social content)
+
+Rules:
+- Timeline edit and scene_composition phases run sequentially (each depends on previous state)
+- Artifact phases can reference the timeline but don't modify it
+- Each phase should be independently verifiable
+- Keep phases focused \u2014 one clear objective per phase
+- Include verification criteria for each phase
+
+OUTPUT FORMAT (JSON only, no markdown):
+{
+  "phases": [
+    {
+      "name": "short-name",
+      "output": "timeline_edit" | "artifact" | "scene_composition",
+      "description": "what this phase does",
+      "verificationCriteria": ["criterion 1", "criterion 2"],
+      "evaluationPasses": 1 | 3
+    }
+  ]
+}
+
+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 COMPLEX_KEYWORDS = /\b(workflow|produce|post-?produce|podcast|episode|batch|multi|series|sequence|blog|show.?notes|thumbnail|description)\b/i;
+function shouldDecompose(task, hasTranscript) {
+  if (task.length < 60 && !hasTranscript) return false;
+  if (COMPLEX_KEYWORDS.test(task)) return true;
+  const clauses = task.split(/,|\band\b/i).filter((c) => c.trim().length > 10);
+  return clauses.length >= 2;
+}
+function singlePhase(task) {
+  return [{
+    name: "execute",
+    output: "timeline_edit",
+    description: task,
+    verificationCriteria: [],
+    evaluationPasses: 0,
+    tools: [],
+    // all tools available
+    status: "pending"
+  }];
+}
+async function decompose(model, task, context) {
+  try {
+    const { object } = await generateObject({
+      model,
+      schema: PhaseSchema,
+      instructions: DECOMPOSER_PROMPT,
+      prompt: `TASK: ${task}
+
+COMPOSITION CONTEXT:
+${context}`,
+      maxOutputTokens: 1500
+    });
+    return object.phases.map((p) => ({
+      ...p,
+      tools: [],
+      status: "pending"
+    }));
+  } catch {
+    return singlePhase(task);
+  }
+}
+
+// ../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 }
+};
+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" ? `
+  // Per-child reveal + sustained breathing: values are computed from the
+  // CURRENT frame and emitted as static nth-child rules \u2014 legal under
+  // Remotion's seek-and-freeze (this is per-frame static CSS, not a CSS
+  // animation). Children live inside the verbatim markup's [data-stagger]
+  // container; extra rules no-op. Breathing gives each tile a phase-offset
+  // \xB1${STAGGER_BREATHE.amp}px float for the whole hold, so a revealed mosaic never freezes.
+  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});
+    // 'translate' (the independent CSS property), NOT 'transform': this rule
+    // out-specifies any author class (0,2,0), so a transform here would
+    // clobber an author rotate/scale on the tile; the independent property
+    // composes with the author transform in Chromium.
+    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}
+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);
+  // SUSTAIN: post-entrance micro-motion for the full remaining clip. 'hold'
+  // runs 0\u21921 linearly from entrance-end to the last frame (linear on purpose \u2014
+  // constant perceived velocity = ambient life); tSec is seconds since the
+  // entrance completed (drives the settle wobble / breathing phases).
+  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";
+  }
+};
+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(", ")}`
+    );
+  }
+  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).`)
+    );
+  }
+  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.`
+    );
+  }
+  return {
+    cardHtml: clip.source.html,
+    // The card's token layer rides with the markup — generateMotionShell bakes
+    // it as `--cf-*` vars so the shelled card keeps the values it was authored
+    // against (the custom render lane applies no token vars).
+    ...clip.source.tokens !== void 0 ? { tokens: clip.source.tokens } : {},
+    // Depth rides through the shell: a behind-subject card must stay behind
+    // after the source swap, or the preset silently pops it in front of the
+    // subject (2026-08-10 issue — the sink's whole-source replace dropped it).
+    ...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, opts, deps) {
+  const out = [];
+  for (let i = 0; i < ops.length; i++) {
+    const op = ops[i];
+    if (!isMotionPresetOp(op)) {
+      out.push(op);
+      continue;
+    }
+    let card;
+    try {
+      card = resolveMotionPresetCard(composition, { clipId: op.clipId, preset: op.preset });
+    } catch (err) {
+      if (err instanceof MotionPresetError) err.opIndex = i;
+      throw err;
+    }
+    if (opts.dryRun) continue;
+    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 componentId = `motion-shell-${op.clipId}`;
+    const { jsSource } = await deps.transpile(componentId, tsxSource);
+    out.push(
+      await deps.sink({
+        componentId,
+        clipId: op.clipId,
+        preset: op.preset,
+        tsxSource,
+        jsSource,
+        ...card.zPlane !== void 0 ? { zPlane: card.zPlane } : {}
+      })
+    );
+  }
+  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,
+  DESIGN_REVIEWER_PROMPT,
+  DESIGN_REVIEWER_TOOLS,
+  EVALUATOR_PROMPT,
+  MOTION_PRESETS,
+  MotionPresetError,
+  PLANNING_INSTRUCTIONS,
+  PipelineTrace as RequestTrace,
+  TIMELINE_RUBRIC,
+  TOOLKIT_REFERENCE,
+  ZERO_USAGE,
+  buildDirectorContext as buildAgentContext,
+  buildDirectorContext,
+  buildDirectorTools,
+  buildExecutionTask,
+  buildFastModel,
+  buildModel,
+  buildPlannerTools,
+  buildPlannerUserMessage,
+  buildPrepareStep,
+  buildToolsFromSchemas,
+  cachePrepareStep,
+  createAgentMemory,
+  decompose,
+  dispatchComposeRoleTool,
+  evaluate,
+  evaluateArtifact,
+  evaluateTimeline,
+  extractProviderError,
+  formatPlanSteps,
+  generateMotionShell,
+  getExcludedTools,
+  hasMotionPresetOp,
+  initCodeGenPrompts,
+  isMotionPresetOp,
+  makeLangfuseFetch,
+  materializeMotionPresetOpsCore,
+  renderSkillContent,
+  resolveMotionPresetCard,
+  shouldDecompose,
+  singlePhase
+};