@impractical-ai/motion 0.1.6 → 0.1.7

package/dist/{stdio-GHDI4S7P.js → stdio-XUVQKDCB.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   openBrowser
-} from "./chunk-BUHNO2W2.js";
+} from "./chunk-M7SHFM25.js";
 import {
   ApiError,
   admitMcpCall,
@@ -11,15 +11,17 @@ import {
   saveConfig,
   validateApiResponse,
   withAdmissionReceipt
-} from "./chunk-KITRCE33.js";
+} from "./chunk-MQKW7NFI.js";
 import {
   PACKAGE_VERSION,
   PRODUCTION_APP_URL,
-  PRODUCTION_SUPABASE_URL,
+  PRODUCTION_SUPABASE_URL
+} from "./chunk-Z74SLKEU.js";
+import {
   __commonJS,
   __export,
   __toESM
-} from "./chunk-LJ4YH3YJ.js";
+} from "./chunk-77HVPD4G.js";
 
 // node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
@@ -378,7 +380,7 @@ var require_codegen = __commonJS({
       AND: new code_1._Code("&&"),
       ADD: new code_1._Code("+")
     };
-    var Node = class {
+    var Node2 = class {
       optimizeNodes() {
         return this;
       }
@@ -386,7 +388,7 @@ var require_codegen = __commonJS({
         return this;
       }
     };
-    var Def = class extends Node {
+    var Def = class extends Node2 {
       constructor(varKind, name, rhs) {
         super();
         this.varKind = varKind;
@@ -409,7 +411,7 @@ var require_codegen = __commonJS({
         return this.rhs instanceof code_1._CodeOrName ? this.rhs.names : {};
       }
     };
-    var Assign = class extends Node {
+    var Assign = class extends Node2 {
       constructor(lhs, rhs, sideEffects) {
         super();
         this.lhs = lhs;
@@ -439,7 +441,7 @@ var require_codegen = __commonJS({
         return `${this.lhs} ${this.op}= ${this.rhs};` + _n;
       }
     };
-    var Label = class extends Node {
+    var Label = class extends Node2 {
       constructor(label) {
         super();
         this.label = label;
@@ -449,7 +451,7 @@ var require_codegen = __commonJS({
         return `${this.label}:` + _n;
       }
     };
-    var Break = class extends Node {
+    var Break = class extends Node2 {
       constructor(label) {
         super();
         this.label = label;
@@ -460,7 +462,7 @@ var require_codegen = __commonJS({
         return `break${label};` + _n;
       }
     };
-    var Throw = class extends Node {
+    var Throw = class extends Node2 {
       constructor(error51) {
         super();
         this.error = error51;
@@ -472,7 +474,7 @@ var require_codegen = __commonJS({
         return this.error.names;
       }
     };
-    var AnyCode = class extends Node {
+    var AnyCode = class extends Node2 {
       constructor(code) {
         super();
         this.code = code;
@@ -491,7 +493,7 @@ var require_codegen = __commonJS({
         return this.code instanceof code_1._CodeOrName ? this.code.names : {};
       }
     };
-    var ParentNode = class extends Node {
+    var ParentNode = class extends Node2 {
       constructor(nodes = []) {
         super();
         this.nodes = nodes;
@@ -2223,8 +2225,8 @@ var require_resolve = __commonJS({
       }
       return count;
     }
-    function getFullPath(resolver, id = "", normalize) {
-      if (normalize !== false)
+    function getFullPath(resolver, id = "", normalize2) {
+      if (normalize2 !== false)
         id = normalizeId(id);
       const p = resolver.parse(id);
       return _getFullPath(resolver, p);
@@ -3620,7 +3622,7 @@ var require_fast_uri = __commonJS({
     "use strict";
     var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
-    function normalize(uri, options) {
+    function normalize2(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
         normalizeString(uri, options);
@@ -3913,7 +3915,7 @@ var require_fast_uri = __commonJS({
     }
     var fastUri = {
       SCHEMES,
-      normalize,
+      normalize: normalize2,
       resolve,
       resolveComponent,
       equal,
@@ -6904,8 +6906,8 @@ var require_dist = __commonJS({
 });
 
 // src/mcp/stdio.ts
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // node_modules/zod/v3/helpers/util.js
 var util;
@@ -31010,6 +31012,315 @@ var UNMETERED_MCP_TOOLS = /* @__PURE__ */ new Set([
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
 
+// src/mcp/quality-loop.ts
+var QUALITY_LOOP_ENV = "IMPRACTICAL_QUALITY_LOOP";
+var meaningful = (label, minimum = 12) => external_exports.string().trim().min(minimum, `${label} must be specific enough to direct from.`);
+var creativeContractSchema = external_exports.object({
+  audience: meaningful("audience", 3),
+  singleIdea: meaningful("singleIdea"),
+  visualProof: meaningful("visualProof"),
+  referenceStrategy: meaningful("referenceStrategy"),
+  productSource: meaningful("productSource"),
+  opening: meaningful("opening"),
+  proof: meaningful("proof"),
+  payoff: meaningful("payoff")
+});
+var qualityScoresSchema = external_exports.object({
+  narrativeClarity: external_exports.number().int().min(1).max(5),
+  visualProof: external_exports.number().int().min(1).max(5),
+  productAuthenticity: external_exports.number().int().min(1).max(5),
+  composition: external_exports.number().int().min(1).max(5),
+  legibility: external_exports.number().int().min(1).max(5),
+  pacing: external_exports.number().int().min(1).max(5),
+  referenceFidelity: external_exports.number().int().min(1).max(5),
+  technicalIntegrity: external_exports.number().int().min(1).max(5)
+});
+var qualityReviewSchema = external_exports.object({
+  reviewedRevision: external_exports.number().int().min(0),
+  singleIdea: meaningful("singleIdea"),
+  visualProof: meaningful("visualProof"),
+  referenceComparison: meaningful("referenceComparison"),
+  scores: qualityScoresSchema,
+  timestampEvidence: external_exports.array(
+    external_exports.object({
+      time: external_exports.number().min(0),
+      finding: meaningful("finding", 5)
+    })
+  ).min(3),
+  blockingIssues: external_exports.array(external_exports.string().trim().min(1))
+});
+var createQualityLoopState = () => ({
+  finalReviewByDraft: /* @__PURE__ */ new Map(),
+  finalMotionReviewByDraft: /* @__PURE__ */ new Map(),
+  lockedContentByDraft: /* @__PURE__ */ new Map(),
+  beatsByDraft: /* @__PURE__ */ new Map(),
+  referenceLedger: null
+});
+function qualityLoopEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env[QUALITY_LOOP_ENV]?.trim() ?? "");
+}
+var hasOpening = (times) => times.some((time3) => time3 <= 0.15);
+var hasEnding = (times, duration3) => duration3 <= 0 || times.some((time3) => time3 >= Math.max(0, duration3 - 0.25));
+function finalReviewCoverageError(times, duration3) {
+  if (times.length < 8) return "Final review needs at least 8 representative frames.";
+  if (!hasOpening(times)) return "Final review must include the opening frame at t=0.";
+  if (!hasEnding(times, duration3)) {
+    return `Final review must include a settled closing frame near t=${duration3.toFixed(2)}s.`;
+  }
+  return null;
+}
+function recordFinalReviewCapture(state, draftId, capture) {
+  state?.finalReviewByDraft.set(draftId, capture);
+}
+function qualityReviewPrompt(mode, contract) {
+  const contractNote = contract ? `
+Creative contract: ${contract.singleIdea} Visual proof: ${contract.visualProof}` : "";
+  if (mode === "proof") {
+    return "\nQUALITY LOOP \u2014 PROOF-SHOT REVIEW. Judge the visible pixels, not the effort or code. Answer with timestamped evidence: (1) can a stranger understand the product transformation, (2) is the real product large and legible, (3) is the result impressive without explanatory copy, (4) is reconstructed UI clearly disclosed rather than called exact, and (5) what must change before building the rest of the film. Do not describe the shot as merely clean." + contractNote;
+  }
+  if (mode === "final") {
+    return "\nQUALITY LOOP \u2014 FINAL CRITIC REVIEW. Treat this as a fresh design-director pass. Score 1\u20135 with timestamped visible evidence: narrative clarity, visual proof, product authenticity, composition/hierarchy, legibility, pacing/variation, reference fidelity, and technical integrity. An empty opening, unreadable product UI, an unsupported marketing claim, stale/reconstructed UI presented as exact, any score below 3, or an average below 4 blocks export. Do not reward implementation effort and do not equate artifact-free with good." + contractNote;
+  }
+  return "\nQUALITY LOOP \u2014 LAYOUT REVIEW. Identify the primary subject at each timestamp and report clipping, unreadable text, weak occupancy, competing hierarchy, missing assets, or empty frames. Use visible evidence rather than saying the frames look clean.";
+}
+function motionCoverageFailure(input) {
+  if (!input.motionLab) return null;
+  if (!input.capture) {
+    return 'The motion lab requires full-duration motion coverage: call get_motion({ draftId, reviewMode: "final" }) and resolve the dead air and imperceptible tweens it reports before exporting.';
+  }
+  if (input.capture.revision !== input.frameReviewRevision) {
+    return `The motion review covered revision ${input.capture.revision}, but the final frame review covered revision ${input.frameReviewRevision}. Review the same revision with both.`;
+  }
+  return null;
+}
+function qualityReviewFailure(input) {
+  const { draftRevision, capture, review } = input;
+  if (!capture) {
+    return 'No eligible final review exists. Call get_frames with reviewMode="final" on at least 8 timestamps including t=0 and the settled closing frame.';
+  }
+  if (capture.revision !== draftRevision) {
+    return `The final review covered revision ${capture.revision}, but the draft is now revision ${draftRevision}. Review the current revision again.`;
+  }
+  if (!review) {
+    return "Attach the timestamped qualityReview scorecard required by the local quality loop.";
+  }
+  if (review.reviewedRevision !== draftRevision) {
+    return `qualityReview says revision ${review.reviewedRevision}, but the current draft is revision ${draftRevision}.`;
+  }
+  if (review.blockingIssues.length) {
+    return `The review still has blocking issues: ${review.blockingIssues.join("; ")}`;
+  }
+  const scores = Object.entries(review.scores);
+  const low = scores.filter(([, score]) => score < 3);
+  if (low.length) {
+    return `Scores below 3 block export: ${low.map(([name, score]) => `${name}=${score}`).join(", ")}.`;
+  }
+  const average = scores.reduce((sum, [, score]) => sum + score, 0) / scores.length;
+  if (average < 4) return `Quality score average ${average.toFixed(2)} is below the 4.0 export floor.`;
+  return null;
+}
+function qualityLoopServerInstructions() {
+  return `
+
+LOCAL QUALITY LOOP IS ENABLED \u2014 this is an opt-in experiment and it is mandatory for new videos:
+1. Before create_video, write and pass its creativeContract: audience, one memorable idea, one visible proof, how the reference will be translated rather than copied, the real product source, and opening/proof/payoff beats.
+2. Build the proof beat first. Call get_frames with reviewMode="proof" and judge whether the product transformation is understandable and impressive before completing the rest.
+3. After the complete cut, call get_frames with reviewMode="final" on at least 8 representative timestamps including t=0 and the settled closing frame. Score what is visibly present; "clean" is not a verdict.
+4. Export only with a timestamped qualityReview for the exact reviewed revision. Any unresolved blocking issue, score below 3, or average below 4 must be fixed and reviewed again.
+This loop changes no scene schema or renderer behavior. It exists to stop technically valid but creatively weak cuts from self-approving.`;
+}
+
+// src/mcp/phased-flow.ts
+var PHASED_FLOW_ENV = "IMPRACTICAL_PHASED_FLOW";
+function phasedFlowEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env[PHASED_FLOW_ENV]?.trim() ?? "");
+}
+var meaningful2 = (label, minimum) => external_exports.string().trim().min(minimum, `${label} must be specific enough to direct from.`);
+var conceptSchema = external_exports.object({
+  /** One sentence: product, user, and the change the viewer will believe. */
+  premise: meaningful2("premise", 20),
+  /** The thing the viewer follows across the whole film (an invoice, a request…). */
+  recurringArtifact: meaningful2("recurringArtifact", 6),
+  /** Evidence gathered BEFORE inventing UI: real code, the product site, images. */
+  references: external_exports.array(
+    external_exports.object({
+      kind: external_exports.enum(["local-code", "website", "screenshot", "image-search"]),
+      detail: meaningful2("reference detail", 5)
+    })
+  ).min(1, "Gather at least one real reference before designing components."),
+  /** Every beat names a MOVE — a beat with no move is not a beat. */
+  beats: external_exports.array(
+    external_exports.object({
+      start: external_exports.number().min(0),
+      end: external_exports.number().min(0),
+      subject: meaningful2("beat subject", 3),
+      move: meaningful2("beat move", 8),
+      purpose: meaningful2("beat purpose", 5),
+      /** Declared energy: rest is legitimate stillness; high must visibly move. */
+      energy: external_exports.enum(["rest", "low", "high"]),
+      /**
+       * What happens to the elements ALREADY on stage when this beat starts:
+       * exit (and how), transform, or deliberately stay. First beat may say
+       * "empty stage". Entrances are cheap; exits are choreography, and a
+       * beat that only describes what enters leaves the last scene's props
+       * loitering in frame.
+       */
+      outgoing: meaningful2("beat outgoing (what the elements already on stage do)", 6)
+    })
+  ).min(4),
+  /**
+   * Every component the film will show, each answering: must this look 1:1
+   * real? 'exact-product' = the actual product's UI; 'realistic-class' = a
+   * real-world object class (a terminal, an invoice); 'stylized' = abstract/
+   * editorial, no reference needed. Non-stylized components MUST name the
+   * reference source that was pulled and viewed for them.
+   */
+  componentInventory: external_exports.array(
+    external_exports.object({
+      name: meaningful2("component", 3),
+      realism: external_exports.enum(["exact-product", "realistic-class", "stylized"]),
+      referenceSource: external_exports.string().trim().min(4).optional()
+    })
+  ).min(1)
+});
+var contentSchema = external_exports.object({
+  /** Every editorial line the film will show, in viewing order. Locked. */
+  lines: external_exports.array(
+    external_exports.object({
+      text: external_exports.string().trim().min(2).max(90),
+      kind: external_exports.enum(["statement", "label", "endcard"])
+    })
+  ).min(3)
+});
+function phasedGateFailure(args) {
+  if (!args.concept || !args.content) {
+    return "The phased flow requires BOTH `concept` and `content` before scaffolding. Phase 1 (concept): from the brief alone \u2014 premise, recurringArtifact, references (look for the product's real code or site FIRST), beats (each with start, end, subject, move, purpose, energy, and outgoing \u2014 what the elements already on stage do when the beat starts), componentInventory. Phase 2 (content): every editorial line the film will show, in viewing order, each marked statement/label/endcard, written so someone who has never heard of the product could repeat it. Do this BEFORE studying the engine or library. The lines are locked: the motion report diffs the rendered film against them.";
+  }
+  const concept = conceptSchema.safeParse(args.concept);
+  if (!concept.success) {
+    const issue2 = concept.error.issues[0];
+    const at = issue2?.path?.length ? ` at ${issue2.path.join(".")}` : "";
+    return `concept invalid${at}: ${issue2?.message ?? "schema mismatch"}`;
+  }
+  const content = contentSchema.safeParse(args.content);
+  if (!content.success) {
+    const issue2 = content.error.issues[0];
+    const at = issue2?.path?.length ? ` at ${issue2.path.join(".")}` : "";
+    return `content invalid${at}: ${issue2?.message ?? "schema mismatch"}`;
+  }
+  const missing = concept.data.componentInventory.filter(
+    (component) => component.realism !== "stylized" && !component.referenceSource
+  );
+  if (missing.length) {
+    return `concept invalid: these components are marked as needing realism but have no referenceSource: ${missing.map((component) => component.name).join(", ")}. For each, pull a real reference image (gather_references / your image search), VIEW it, and record its source \u2014 or mark the component stylized if it genuinely needs no real-world counterpart.`;
+  }
+  return null;
+}
+var CONTENT_DOCTRINE_ENV = "IMPRACTICAL_CONTENT_DOCTRINE";
+function contentDoctrineEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env[CONTENT_DOCTRINE_ENV]?.trim() ?? "");
+}
+var contentDoctrine = () => contentDoctrineEnabled() ? ` Write every line so a smart 16-year-old who has never heard of the product gets it on first read \u2014 if they couldn't repeat it back in their own words, rewrite it. No insider jargon: name what the thing DOES in plain words, not its category ("your agent gets its own email address", never "agentic email infrastructure"). Say it, then show it: a statement makes ONE plain claim, and the very next thing the film does is prove that claim on camera. One thing to read at a time \u2014 never two lines competing for the same moment.` : " Write them plain enough for someone who has never heard of the product.";
+var contentTextRule = () => contentDoctrineEnabled() ? " That floor governs EDITORIAL lines \u2014 the film's own statements and labels \u2014 and it is not a ban on words inside the product you are showing. Recreate the product's own content as real, plausible words at whatever size the real interface uses. NEVER replace product content with grey placeholder bars or skeleton rectangles: a wireframe reads as a loading screen, and a film that claims the software works while showing an empty shell has proved nothing. Small real text is what makes an interface look real; the rule is that the viewer must never NEED to read it, not that it must be absent." : "";
+function phasedServerInstructions() {
+  return `
+
+PHASED FLOW IS ENABLED \u2014 work in three phases, in order:
+1. CONCEPT \u2014 from the brief alone, before engine_types or motion_context: FIRST study references, then call gather_references (required \u2014 create_video refuses without it). If you have native web/image search and an image-viewing tool, USE THEM: search real screenshots of the product in use and of each component class, download and VIEW them before designing anything. Hunt references of the ACTUAL SOFTWARE, not the marketing homepage \u2014 the product's real front-end code on this machine (pass it as appCode) \u2192 screenshots of the product IN USE (its app/editor/dashboard, found via its docs, help center, changelog, demo videos, review sites) \u2192 its site code \u2192 marketing site (styling tokens only) \u2192 real images of the component class \u2192 mockups; design components to match what the references actually show. Then ask of every component the film will show: MUST THIS LOOK 1:1 REAL? Product UI and real-world objects (a terminal, an invoice, a dashboard) do; abstract backdrops and statement cards do not. For each realism-required component, pull a real reference image, VIEW it, and record it as that component's referenceSource in the inventory. Then write the premise, the one recurring artifact the viewer follows, and beats where every beat names a MOVE, declares its energy (rest / low / high) \u2014 rest is legitimate stillness, high must visibly move; the motion report verdicts each beat against its declaration \u2014 and declares its OUTGOING: what the elements already on stage do when this beat starts. Nothing new enters without saying what the things still showing do \u2014 exit (and how), transform into the new thing, or deliberately stay. Entrances are cheap; exits are choreography. A beat that only describes what arrives leaves the last scene's props loitering in frame. The first beat may say "empty stage".
+2. CONTENT \u2014 write every editorial line of the film in viewing order (statement/label/endcard).${contentDoctrine()} Statements are the big lines the film is built around \u2014 10-15% of frame height each; no text anyone MUST read below 4% unless the user explicitly asks.${contentTextRule()} These lines are LOCKED once passed to create_video: the motion report flags any on-screen line that is not in the list, and any listed line the camera never shows.
+RUNTIME \u2014 when the user gives no duration, plan 20-30 seconds and EARN it with at least two distinct proof chapters (different capabilities or angles), never by stretching holds. A user-specified runtime always wins.
+3. CREATION \u2014 only now read engine_types and motion_context. Call install_kits on the new draft FIRST and import the primitives from './kit/*' \u2014 the cursor actor, showpieces, looks and sentence typography are already built and tuned; hand-rolling them produces cursors that teleport and clicks that fire early. Then cast the beats onto the library and kits, build, measure, revise, review, export.
+create_video requires the concept and content artifacts and will refuse without them.`;
+}
+
+// src/mcp/preflight.ts
+var esbuildPromise = null;
+function loadEsbuild() {
+  esbuildPromise ??= import("./main-BEONOBG5.js").then(
+    (mod) => mod,
+    () => null
+  );
+  return esbuildPromise;
+}
+var LOADERS = {
+  ".tsx": "tsx",
+  ".ts": "ts",
+  ".jsx": "jsx",
+  ".js": "js",
+  ".css": "css",
+  ".json": "json"
+};
+function resolveDraftPath(files, request) {
+  const clean = request.replace(/^\.\//, "");
+  const candidates = [
+    clean,
+    `${clean}.ts`,
+    `${clean}.tsx`,
+    `${clean}.js`,
+    `${clean}.jsx`,
+    `${clean}/index.ts`,
+    `${clean}/index.tsx`
+  ];
+  return candidates.find((candidate) => candidate in files) ?? null;
+}
+async function preflightDraft(files) {
+  const esbuild = await loadEsbuild();
+  if (!esbuild) return null;
+  const entries = ["App.tsx", "direction.ts"].filter((entry) => entry in files);
+  if (!entries.length) return null;
+  try {
+    await esbuild.build({
+      entryPoints: entries.map((entry) => `draft:${entry}`),
+      bundle: true,
+      write: false,
+      // write:false never touches disk; outdir is still required for multiple entries.
+      outdir: "preflight-virtual",
+      platform: "browser",
+      format: "esm",
+      logLevel: "silent",
+      plugins: [
+        {
+          name: "draft-virtual-fs",
+          setup(build) {
+            build.onResolve({ filter: /^draft:/ }, (args) => ({
+              path: args.path.slice("draft:".length),
+              namespace: "draft"
+            }));
+            build.onResolve({ filter: /.*/ }, (args) => {
+              if (args.namespace !== "draft") return void 0;
+              if (args.path.startsWith("./")) {
+                const dir = args.importer.includes("/") ? args.importer.slice(0, args.importer.lastIndexOf("/") + 1) : "";
+                const joined = dir + args.path.slice(2);
+                const resolved = resolveDraftPath(files, joined);
+                if (resolved) return { path: resolved, namespace: "draft" };
+                return {
+                  errors: [
+                    {
+                      text: `"${args.path}" (from ${args.importer}) does not match any draft file. Draft files: ${Object.keys(files).sort().join(", ")}`
+                    }
+                  ]
+                };
+              }
+              return { path: args.path, external: true };
+            });
+            build.onLoad({ filter: /.*/, namespace: "draft" }, (args) => {
+              const ext = args.path.slice(args.path.lastIndexOf("."));
+              return {
+                contents: files[args.path],
+                loader: LOADERS[ext] ?? "ts"
+              };
+            });
+          }
+        }
+      ]
+    });
+    return null;
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    return message;
+  }
+}
+
 // src/mcp/tools.ts
 var json2 = (value) => ({ text: JSON.stringify(value, null, 2) });
 var fail = (text) => ({ text, isError: true });
@@ -31059,6 +31370,14 @@ async function saveDraft(ctx, draftId, apply) {
     if (!changedCount && !change.deletedPaths.length) {
       return { text: `No change \u2014 the draft already matches at revision ${draft.revision}.` };
     }
+    const merged = { ...draft.files, ...change.files };
+    for (const deleted of change.deletedPaths) delete merged[deleted];
+    const preflightError = await preflightDraft(merged);
+    if (preflightError) {
+      return fail(
+        "Local build preflight failed \u2014 nothing was sent to the cloud, fix and save again:\n" + preflightError
+      );
+    }
     try {
       const saved = await ctx.invoke("save-draft", {
         draftId,
@@ -31066,6 +31385,8 @@ async function saveDraft(ctx, draftId, apply) {
         files: change.files,
         deletedPaths: change.deletedPaths
       });
+      ctx.qualityLoopState?.finalReviewByDraft.delete(draftId);
+      ctx.qualityLoopState?.finalMotionReviewByDraft.delete(draftId);
       return reportBuildStart(
         draftId,
         saved,
@@ -31219,9 +31540,32 @@ var createVideo = {
     templateParams: external_exports.record(external_exports.string(), external_exports.string()).optional().describe("Parameters for templateId, using the schema returned by motion_context."),
     motionContextId: external_exports.string().optional().describe(
       "contextId from the motion_context result. Pins the draft to the personalized recommendations that produced it. Omit to resolve a fresh context."
+    ),
+    creativeContract: creativeContractSchema.optional().describe(
+      "Required only when the local quality-loop experiment is enabled: the audience, one memorable idea, visible proof, reference strategy, product source, and opening/proof/payoff."
+    ),
+    concept: conceptSchema.optional().describe(
+      "Required only when the phased flow is enabled: premise, recurringArtifact, references, beats (each with a MOVE), and componentInventory \u2014 authored from the brief alone."
+    ),
+    content: contentSchema.optional().describe(
+      "Required only when the phased flow is enabled: every editorial line in viewing order (claim/label/endcard). Locked \u2014 the motion report diffs the film against these lines."
     )
   },
   handler: async (args, ctx) => {
+    if (ctx.qualityLoop && !args.creativeContract) {
+      return fail(
+        "The local quality loop requires creativeContract before scaffolding. Name the audience, singleIdea, visualProof, referenceStrategy, productSource, opening, proof, and payoff. This is a planning gate only; it does not change the scene schema."
+      );
+    }
+    if (ctx.phasedFlow) {
+      const gate = phasedGateFailure({ concept: args.concept, content: args.content });
+      if (gate) return fail(gate);
+      if (!ctx.qualityLoopState?.referenceLedger) {
+        return fail(
+          "The phased flow requires gather_references BEFORE create_video: record the real references this film is designed against (or an honest noneFound after exhausting the ladder: local code -> product site -> screenshots -> component-class images)."
+        );
+      }
+    }
     let brand = null;
     if (args.brandSlug) {
       const result = await ctx.invoke("brand-kits", {
@@ -31246,6 +31590,24 @@ var createVideo = {
       ...args.motionContextId ? { motionContextId: args.motionContextId } : {}
     });
     const draft = prepared.drafts[0];
+    if (ctx.phasedFlow && draft?.id && args.content) {
+      const parsedContent = contentSchema.safeParse(args.content);
+      if (parsedContent.success) {
+        ctx.qualityLoopState?.lockedContentByDraft.set(draft.id, parsedContent.data.lines);
+      }
+      const parsedConcept = conceptSchema.safeParse(args.concept);
+      if (parsedConcept.success) {
+        ctx.qualityLoopState?.beatsByDraft.set(
+          draft.id,
+          parsedConcept.data.beats.map((beat) => ({
+            start: beat.start,
+            end: beat.end,
+            subject: beat.subject,
+            energy: beat.energy
+          }))
+        );
+      }
+    }
     return json2({
       projectId: prepared.projectId,
       draftId: draft?.id,
@@ -31254,7 +31616,14 @@ var createVideo = {
       libraryVersion: prepared.libraryVersion,
       engineVersion: prepared.engineVersion,
       studioUrl: studioLink(ctx, prepared.projectId, draft?.slug),
-      next: "Read impractical://engine.d.ts, then write App.tsx and direction.ts."
+      ...ctx.qualityLoop ? {
+        creativeContract: args.creativeContract,
+        qualityLoop: {
+          enabled: true,
+          next: 'Build the proof beat first, then call get_frames with reviewMode="proof" before completing the full film.'
+        }
+      } : {},
+      next: ctx.qualityLoop ? "Read impractical://engine.d.ts, build the proof beat first, then review it before completing the film." : "Read impractical://engine.d.ts, then write App.tsx and direction.ts."
     });
   }
 };
@@ -31421,9 +31790,25 @@ var exportVideo = {
   title: "Export the final MP4",
   description: "Start the final MP4 render and return its job id immediately. Follow that id with job_status for the signed download URL. Only export once the user is happy with the frames.",
   inputSchema: {
-    draftId: external_exports.string().describe("The draft id.")
+    draftId: external_exports.string().describe("The draft id."),
+    qualityReview: qualityReviewSchema.optional().describe(
+      "Required only by the opt-in local quality loop: the exact reviewed revision, creative claim/proof, reference comparison, eight category scores, timestamp evidence, and blockers."
+    )
   },
   handler: async (args, ctx) => {
+    if (ctx.qualityLoop) {
+      const capture = ctx.qualityLoopState?.finalReviewByDraft.get(String(args.draftId));
+      const failure = qualityReviewFailure({
+        draftRevision: capture?.revision ?? -1,
+        capture,
+        review: args.qualityReview
+      }) ?? motionCoverageFailure({
+        motionLab: ctx.motionLab === true,
+        capture: ctx.qualityLoopState?.finalMotionReviewByDraft.get(String(args.draftId)),
+        frameReviewRevision: capture?.revision ?? -1
+      });
+      if (failure) return fail(`Quality gate blocked export: ${failure}`);
+    }
     const started = await ctx.invoke("start-export", { draftId: args.draftId });
     return json2({
       started: true,
@@ -31614,6 +31999,51 @@ Underlying error: ${error51 instanceof Error ? error51.message : String(error51)
     }
   }
 }
+async function renderSettledFrame(page, time3) {
+  await page.evaluate(
+    (seconds) => (async () => {
+      const stage = window;
+      if (stage.__renderAt) stage.__renderAt(seconds);
+      else stage.__seek(seconds);
+      if (stage.__frameSettle) {
+        await stage.__frameSettle();
+      } else {
+        await new Promise((resolve) => {
+          const pending = [...document.querySelectorAll("video")].filter(
+            (video) => video.currentSrc && !video.error && video.seeking
+          );
+          if (!pending.length) {
+            resolve();
+            return;
+          }
+          let finished = false;
+          let remaining = pending.length;
+          const finish = () => {
+            if (finished) return;
+            finished = true;
+            clearTimeout(cap);
+            resolve();
+          };
+          const cap = setTimeout(finish, 1e3);
+          for (const video of pending) {
+            video.addEventListener(
+              "seeked",
+              () => {
+                remaining -= 1;
+                if (remaining === 0) finish();
+              },
+              { once: true }
+            );
+          }
+        });
+      }
+      await new Promise(
+        (resolve) => requestAnimationFrame(() => requestAnimationFrame(() => resolve()))
+      );
+    })(),
+    time3
+  );
+}
 async function captureReferenceFrames(input) {
   const browser = await launchChromium();
   try {
@@ -31639,14 +32069,7 @@ async function captureReferenceFrames(input) {
     );
     const images = [];
     for (const time3 of times) {
-      await page.evaluate(
-        (seconds) => new Promise((resolve) => {
-          ;
-          window.__seek(seconds);
-          requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
-        }),
-        time3
-      );
+      await renderSettledFrame(page, time3);
       const frame = await page.screenshot({ type: FRAME_TYPE, quality: FRAME_QUALITY });
       images.push({ base64: frame.toString("base64"), mimeType: FRAME_MIME });
     }
@@ -31683,8 +32106,8 @@ async function resolvePreview(ctx, draftId) {
     artifactRevision: preview.source_revision
   };
 }
-async function captureFrames(ctx, input) {
-  const preview = await resolvePreview(ctx, input.draftId);
+async function openPreview(ctx, draftId) {
+  const preview = await resolvePreview(ctx, draftId);
   const warnings = [];
   if (preview.artifactRevision !== preview.revision) {
     warnings.push(
@@ -31723,6 +32146,7 @@ async function captureFrames(ctx, input) {
       await page.setViewportSize({ width: config2.width, height: config2.height });
     }
     const duration3 = Number(await page.evaluate(() => window.__duration)) || 0;
+    const fps = Number(config2?.fps) || 30;
     const fontsFailed = await page.evaluate(async () => {
       await document.fonts.ready;
       return [...document.fonts].some((font) => font.status === "error");
@@ -31732,41 +32156,26 @@ async function captureFrames(ctx, input) {
         "Some web fonts failed to load, so typography in these frames is not final. Frame capture needs network access to fonts.googleapis.com."
       );
     }
+    return { browser, page, duration: duration3, fps, revision: preview.artifactRevision, warnings };
+  } catch (error51) {
+    await browser.close().catch(() => void 0);
+    throw error51;
+  }
+}
+async function captureFrames(ctx, input) {
+  const session = await openPreview(ctx, input.draftId);
+  const { page, duration: duration3, warnings, revision } = session;
+  try {
     const images = [];
     for (const time3 of input.times) {
       const clamped = duration3 > 0 ? Math.max(0, Math.min(time3, duration3)) : Math.max(0, time3);
-      await page.evaluate(
-        (seconds) => new Promise((resolve) => {
-          ;
-          window.__seek(seconds);
-          const finish = () => requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
-          const pending = [...document.querySelectorAll("video")].filter(
-            (video) => video.currentSrc && !video.error && video.seeking
-          );
-          if (!pending.length) return finish();
-          let remaining = pending.length;
-          const cap = setTimeout(finish, 1e3);
-          for (const video of pending) {
-            video.addEventListener(
-              "seeked",
-              () => {
-                if (--remaining === 0) {
-                  clearTimeout(cap);
-                  finish();
-                }
-              },
-              { once: true }
-            );
-          }
-        }),
-        clamped
-      );
+      await renderSettledFrame(page, clamped);
       const frame = await page.screenshot({ type: FRAME_TYPE, quality: FRAME_QUALITY });
       images.push({ base64: frame.toString("base64"), mimeType: FRAME_MIME });
     }
-    return { images, warnings, revision: preview.artifactRevision, duration: duration3 };
+    return { images, warnings, revision, duration: duration3 };
   } finally {
-    await browser.close().catch(() => void 0);
+    await session.browser.close().catch(() => void 0);
   }
 }
 var getFramesTool = {
@@ -31775,7 +32184,10 @@ var getFramesTool = {
   description: "Render frames of the draft at the given times (in seconds) and return them as images, so you can SEE your work instead of guessing. Runs on this machine against the cloud preview bundle \u2014 it needs Chrome installed. Ask for several times in one call: the frames are nearly free once the page is open. Always look at frames before telling the user a change is done.",
   inputSchema: {
     draftId: external_exports.string().describe("The draft id."),
-    times: external_exports.array(external_exports.number().min(0)).min(1).max(12).describe("Timeline positions in seconds, e.g. [0, 1.5, 3].")
+    times: external_exports.array(external_exports.number().min(0)).min(1).max(12).describe("Timeline positions in seconds, e.g. [0, 1.5, 3]."),
+    reviewMode: external_exports.enum(["layout", "proof", "final"]).optional().describe(
+      "Opt-in quality-loop lens. proof judges the core transformation before the full film; final requires broad timeline coverage and produces export-eligible review evidence."
+    )
   },
   local: true,
   handler: async (args, ctx) => {
@@ -31787,127 +32199,2251 @@ var getFramesTool = {
       `Captured ${capture.images.length} frame(s) at revision ${capture.revision} (scene duration ${capture.duration.toFixed(2)}s).`,
       ...capture.warnings.map((warning) => `WARNING: ${warning}`)
     ];
+    const reviewMode = args.reviewMode;
+    if (ctx.qualityLoop) {
+      if (!reviewMode) {
+        lines.push(
+          'QUALITY LOOP: choose reviewMode="proof" for the core proof beat or reviewMode="final" for the export review.'
+        );
+      } else {
+        if (reviewMode === "final") {
+          const coverageError = finalReviewCoverageError(args.times, capture.duration);
+          const stalePreview = capture.warnings.some(
+            (warning) => warning.startsWith("The preview bundle is at revision ")
+          );
+          if (stalePreview) {
+            lines.push(
+              "QUALITY REVIEW NOT RECORDED: these frames came from a stale preview bundle. Wait for the current revision to build, then review it again."
+            );
+          } else if (coverageError) {
+            lines.push(`QUALITY REVIEW NOT RECORDED: ${coverageError}`);
+          } else {
+            recordFinalReviewCapture(ctx.qualityLoopState, String(args.draftId), {
+              revision: capture.revision,
+              duration: capture.duration,
+              times: [...args.times]
+            });
+            lines.push(
+              `FINAL REVIEW RECORDED for revision ${capture.revision}. Any later edit invalidates this evidence.`
+            );
+          }
+        }
+        lines.push(qualityReviewPrompt(reviewMode));
+      }
+    }
     return { text: lines.join("\n"), images: capture.images };
   }
 };
 
-// src/mcp/connect.ts
-var CONNECT_WAIT_SECONDS = 300;
-async function connectWorkspace(input, deps) {
-  const grant = await deps.request(deps.supabaseUrl, "cli-device-auth", {
-    action: "start"
+// src/mcp/metric-catalog.ts
+var CATALOG_VERSION = "inspect-video-metrics/catalog-v1";
+var STATIC_THRESHOLD = 5e-3;
+var ACTIVE_THRESHOLD = 0.01;
+var ANALYSIS_WIDTH = 192;
+var FINAL_DISTINCT_THRESHOLD = 0.03;
+function metricCatalogEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env.IMPRACTICAL_METRIC_CATALOG?.trim() ?? "");
+}
+var mean = (xs) => xs.reduce((s, x) => s + x, 0) / xs.length;
+function percentile(xs, p) {
+  const sorted = [...xs].sort((a, b) => a - b);
+  const pos = (sorted.length - 1) * p;
+  const lo = Math.floor(pos);
+  const hi = Math.ceil(pos);
+  return sorted[lo] + (sorted[hi] - sorted[lo]) * (pos - lo);
+}
+var median = (xs) => percentile(xs, 0.5);
+var mad = (xs) => {
+  const m = median(xs);
+  return median(xs.map((x) => Math.abs(x - m)));
+};
+function runs(xs, holds) {
+  const out = [];
+  let current = 0;
+  for (const x of xs) {
+    if (holds(x)) current += 1;
+    else if (current) {
+      out.push(current);
+      current = 0;
+    }
+  }
+  if (current) out.push(current);
+  return out;
+}
+function peakIndices(m) {
+  if (m.length < 3) return [];
+  const threshold = median(m) + 1.5 * mad(m);
+  const out = [];
+  for (let i = 1; i < m.length - 1; i += 1) {
+    if (m[i] > m[i - 1] && m[i] >= m[i + 1] && m[i] > threshold) out.push(i);
+  }
+  return out;
+}
+var UNIMPLEMENTED = [
+  { name: "edge_density_median", label: "Structural edge density", unit: "fraction of pixels" },
+  { name: "edge_density_iqr", label: "Structural density variation", unit: "fraction of pixels" },
+  { name: "text_like_occupancy_median", label: "Text-like screen occupancy", unit: "fraction of pixels" },
+  { name: "text_like_border_contact_share", label: "Text-like border contact", unit: "fraction of components" },
+  { name: "text_like_safe_margin_p05", label: "Text-like safe margin", unit: "fraction of shorter dimension" },
+  { name: "composition_balance_mean", label: "High-frequency composition balance", unit: "[0,1] proxy" },
+  { name: "saliency_center_offset_mean", label: "Saliency-center offset", unit: "fraction of frame diagonal" },
+  { name: "saliency_center_speed_mean_per_s", label: "Saliency-center travel speed", unit: "diagonal fractions per second" },
+  { name: "global_translation_mean_frame_fraction_per_s", label: "Mean global translation speed", unit: "frame-width fractions per second" },
+  { name: "global_translation_p90_frame_fraction_per_s", label: "High global translation speed", unit: "frame-width fractions per second" },
+  { name: "global_translation_response_median", label: "Global-translation fit response", unit: "phase-correlation response" },
+  { name: "residual_motion_ratio_median", label: "Residual motion after translation", unit: "ratio" },
+  { name: "motion_edge_alignment_median", label: "Motion-boundary edge alignment", unit: "fraction of boundary pixels" },
+  { name: "edge_turnover_mean", label: "Structural edge turnover", unit: "Jaccard distance" },
+  { name: "layer_turnover_event_rate_per_minute", label: "Layer-turnover proxy rate", unit: "events per minute" }
+];
+function computeCatalogMetrics(input) {
+  const { m, cells, centroids, width, height, finalStateDistinctiveness } = input.features;
+  const dt = Math.max(input.dtSeconds, 1e-6);
+  const duration3 = Math.max(input.durationSeconds, 1e-6);
+  const minutes = Math.max(duration3 / 60, 1e-9);
+  const diagonal = Math.hypot(width, height);
+  const provisional = (name, label, unit, value) => ({
+    name,
+    label,
+    unit,
+    value,
+    status: "PROVISIONAL"
   });
-  const browserOpened = deps.open(grant.verificationUri);
-  const expiry = Date.parse(grant.expiresAt);
-  const deadline = Math.min(
-    deps.now() + input.waitMs,
-    Number.isNaN(expiry) ? Infinity : expiry
+  const accel = m.length >= 2 ? mean(Array.from({ length: m.length - 1 }, (_, i) => Math.abs((m[i + 1] - m[i]) / dt))) : 0;
+  const jerk = m.length >= 3 ? mean(Array.from({ length: m.length - 2 }, (_, i) => Math.abs((m[i + 2] - 2 * m[i + 1] + m[i]) / (dt * dt)))) : 0;
+  const staticRuns = runs(m, (x) => x <= STATIC_THRESHOLD);
+  const peaks = peakIndices(m);
+  const peakGaps = peaks.slice(1).map((p, i) => (p - peaks[i]) * dt);
+  const gapCv = peakGaps.length >= 2 ? Math.sqrt(mean(peakGaps.map((g) => (g - mean(peakGaps)) ** 2))) / mean(peakGaps) : 0;
+  const second = m.length >= 3 ? Array.from({ length: m.length - 2 }, (_, i) => Math.abs(m[i + 2] - 2 * m[i + 1] + m[i])) : [];
+  const smoothness = second.length ? 1 / (1 + percentile(second, 0.9) / (median(m) + 1e-6)) : 1;
+  const cutThreshold = Math.max(0.08, median(m) + 4 * mad(m));
+  const hardCuts = m.filter((x) => x > cutThreshold).length;
+  const LOG16 = Math.log(16);
+  const perInterval = cells.map((cell) => {
+    const total = cell.reduce((s, x) => s + x, 0);
+    if (total <= 0) return { concentration: 0, largest: 0 };
+    const shares = cell.map((x) => x / total);
+    const entropy = -shares.reduce((s, p) => p > 0 ? s + p * Math.log(p) : s, 0);
+    return { concentration: 1 - entropy / LOG16, largest: Math.max(...shares) };
+  });
+  const centroidOffsets = centroids.map(
+    (c) => Math.hypot(c.x - width / 2, c.y - height / 2) / diagonal
   );
-  const intervalMs = Math.max(1, grant.intervalSeconds || 2) * 1e3;
-  while (deps.now() < deadline) {
-    let poll;
-    try {
-      poll = await deps.request(deps.supabaseUrl, "cli-device-auth", {
-        action: "poll",
-        deviceCode: grant.deviceCode
-      });
-    } catch (error51) {
-      if (error51 instanceof ApiError && error51.status === 410) break;
-      throw error51;
-    }
-    if (poll.status === "authorized") {
-      deps.persist({
-        apiKey: poll.apiKey,
-        supabaseUrl: deps.supabaseUrl,
-        appUrl: deps.appUrl
-      });
-      return { status: "connected", userCode: grant.userCode, browserOpened };
-    }
-    await deps.sleep(intervalMs);
-  }
-  return {
-    status: "timeout",
-    userCode: grant.userCode,
-    verificationUri: grant.verificationUri,
-    browserOpened
-  };
+  const centroidSpeeds = centroids.slice(1).map(
+    (c, i) => Math.hypot(c.x - centroids[i].x, c.y - centroids[i].y) / diagonal / dt
+  );
+  let trailing = 0;
+  for (let i = m.length - 1; i >= 0 && m[i] <= STATIC_THRESHOLD; i -= 1) trailing += 1;
+  const terminalShare = trailing * dt / duration3;
+  const peakIndex = m.indexOf(Math.max(...m));
+  const postPeakRuns = runs(m.slice(peakIndex + 1), (x) => x <= STATIC_THRESHOLD);
+  const implemented = [
+    provisional("motion_magnitude_mean", "Mean frame-to-frame motion", "normalized change per interval", mean(m)),
+    provisional("motion_magnitude_median", "Median frame-to-frame motion", "normalized change per interval", median(m)),
+    provisional("motion_magnitude_p90", "High-motion magnitude", "normalized change per interval", percentile(m, 0.9)),
+    provisional("motion_acceleration_abs_mean_per_s", "Mean absolute motion acceleration", "change per second", accel),
+    provisional("motion_jerk_abs_mean_per_s2", "Mean absolute motion jerk", "change per second squared", jerk),
+    provisional("static_exposure_share", "Static exposure", "fraction of intervals", mean(m.map((x) => x <= STATIC_THRESHOLD ? 1 : 0))),
+    provisional("active_interval_share", "Active-motion exposure", "fraction of intervals", mean(m.map((x) => x >= ACTIVE_THRESHOLD ? 1 : 0))),
+    provisional("longest_static_hold_share", "Longest static hold", "fraction of duration", staticRuns.length ? Math.max(...staticRuns) * dt / duration3 : 0),
+    provisional("motion_peak_rate_per_minute", "Motion peak rate", "peaks per minute", peaks.length / minutes),
+    provisional("cadence_gap_cv", "Cadence-gap variability", "dimensionless", gapCv),
+    provisional("transition_smoothness_index", "Transition smoothness proxy", "[0,1] proxy", smoothness),
+    provisional("hard_cut_rate_per_minute", "Hard-cut proxy rate", "events per minute", hardCuts / minutes),
+    provisional("motion_concentration_median", "Spatial motion concentration", "[0,1] entropy concentration", median(perInterval.map((c) => c.concentration))),
+    provisional("largest_motion_cell_share_median", "Largest local motion share", "fraction of energy", median(perInterval.map((c) => c.largest))),
+    provisional("motion_centroid_offset_mean", "Motion-center offset", "fraction of diagonal", mean(centroidOffsets)),
+    provisional("motion_centroid_speed_mean_per_s", "Motion-center travel speed", "diagonal fractions per second", centroidSpeeds.length ? mean(centroidSpeeds) : 0)
+  ];
+  const tail = [
+    provisional("terminal_static_hold_share", "Terminal static hold", "fraction of duration", terminalShare),
+    provisional("post_peak_longest_static_hold_share", "Longest hold after maximum motion", "fraction of duration", postPeakRuns.length ? Math.max(...postPeakRuns) * dt / duration3 : 0),
+    provisional("final_state_distinctiveness", "Final-state visual distinctiveness", "mean absolute change", finalStateDistinctiveness),
+    provisional("proof_hold_proxy_share", "Distinct final hold proxy", "fraction of duration", finalStateDistinctiveness >= FINAL_DISTINCT_THRESHOLD ? terminalShare : 0)
+  ];
+  const nulls = UNIMPLEMENTED.map((metric) => ({
+    ...metric,
+    value: null,
+    status: "NULL",
+    nullReason: "MISSING_INPUT"
+  }));
+  return [...implemented, ...nulls, ...tail];
 }
-var connectTool = {
-  name: "connect",
-  title: "Connect this workspace",
-  description: "Authenticate Impractical Motion for this machine. Opens the user's browser to approve the connection, waits for them to confirm, and stores the credential locally. TELL THE USER YOU ARE ABOUT TO OPEN THEIR BROWSER BEFORE CALLING THIS \u2014 the call blocks until they approve. Use it whenever a tool reports that the workspace is not connected.",
-  inputSchema: {
-    waitSeconds: external_exports.number().optional().describe(`How long to wait for browser approval. Default ${CONNECT_WAIT_SECONDS}.`)
-  },
-  local: true,
-  handler: async (args, ctx) => {
-    const stored = loadConfig();
-    const supabaseUrl = stored.supabaseUrl ?? PRODUCTION_SUPABASE_URL;
-    const appUrl = stored.appUrl ?? PRODUCTION_APP_URL;
-    const result = await connectWorkspace(
-      // Capped like every other wait: a browser approval that outlives the MCP
-      // client's request deadline reports a failure the user then repeats,
-      // burning a second device grant on an approval that already worked.
-      { waitMs: waitBudgetMs(args.waitSeconds, CONNECT_WAIT_SECONDS) },
-      {
-        request: (url2, name, body) => invokeAt(url2, name, body),
-        open: openBrowser,
-        persist: saveConfig,
-        sleep: (ms) => ctx.sleep ? ctx.sleep(ms) : new Promise((r) => setTimeout(r, ms)),
-        now: () => Date.now(),
-        supabaseUrl,
-        appUrl
+function formatCatalogReport(records) {
+  const lines = [];
+  lines.push(`CANONICAL METRICS (${CATALOG_VERSION}, preview stage \u2014 all values PROVISIONAL):`);
+  for (const record2 of records) {
+    if (record2.value === null) continue;
+    const value = Math.abs(record2.value) >= 100 ? record2.value.toFixed(1) : record2.value.toFixed(4);
+    lines.push(`  ${record2.name} = ${value}  (${record2.label}; ${record2.unit})`);
+  }
+  const missing = records.filter((record2) => record2.value === null);
+  lines.push(
+    `  ${missing.length} metrics null MISSING_INPUT (edge/text/saliency/translation families not ported yet).`
+  );
+  lines.push(
+    "  These are descriptive proxies, not grades \u2014 never optimize them directly; use them to find where to look."
+  );
+  return lines.join("\n");
+}
+async function sampleCatalogFeatures(page, frames) {
+  return page.evaluate(
+    async (input) => {
+      const imgs = [];
+      for (const [index, base643] of input.frames.entries()) {
+        const img = new Image();
+        await new Promise((resolve, reject) => {
+          img.onload = () => resolve();
+          img.onerror = () => reject(new Error(`catalog frame ${index} failed to load`));
+          img.src = "data:image/jpeg;base64," + base643;
+        });
+        imgs.push(img);
+      }
+      const w = input.analysisWidth;
+      const h = Math.max(1, Math.round(w * imgs[0].naturalHeight / Math.max(1, imgs[0].naturalWidth)));
+      const canvas = document.createElement("canvas");
+      canvas.width = w;
+      canvas.height = h;
+      const ctx = canvas.getContext("2d", { willReadFrequently: true });
+      if (!ctx) throw new Error("2d canvas unavailable");
+      const grays = [];
+      for (const img of imgs) {
+        ctx.drawImage(img, 0, 0, w, h);
+        const data = ctx.getImageData(0, 0, w, h).data;
+        const gray = new Float32Array(w * h);
+        for (let i = 0; i < gray.length; i += 1) {
+          const o = i * 4;
+          gray[i] = (0.299 * data[o] + 0.587 * data[o + 1] + 0.114 * data[o + 2]) / 255;
+        }
+        grays.push(gray);
+      }
+      const m = [];
+      const cells = [];
+      const centroids = [];
+      for (let f = 1; f < grays.length; f += 1) {
+        const a = grays[f - 1];
+        const b = grays[f];
+        let sum = 0;
+        const cell = new Array(16).fill(0);
+        let cx = 0;
+        let cy = 0;
+        for (let y = 0; y < h; y += 1) {
+          const row = Math.min(3, Math.floor(y * 4 / h)) * 4;
+          for (let x = 0; x < w; x += 1) {
+            const d = Math.abs(b[y * w + x] - a[y * w + x]);
+            sum += d;
+            cell[row + Math.min(3, Math.floor(x * 4 / w))] += d;
+            cx += d * x;
+            cy += d * y;
+          }
+        }
+        m.push(sum / (w * h));
+        cells.push(cell);
+        centroids.push(sum > 0 ? { x: cx / sum, y: cy / sum } : { x: w / 2, y: h / 2 });
       }
-    );
-    if (result.status === "timeout") {
+      const avgOf = (list) => {
+        const out = new Float32Array(w * h);
+        for (const gray of list) for (let i = 0; i < out.length; i += 1) out[i] += gray[i] / list.length;
+        return out;
+      };
+      const first = avgOf(grays.slice(0, Math.min(3, grays.length)));
+      const last = avgOf(grays.slice(-Math.min(3, grays.length)));
+      let distinct = 0;
+      for (let i = 0; i < first.length; i += 1) distinct += Math.abs(last[i] - first[i]);
       return {
-        text: `Nobody approved the connection in time. Ask the user to open ${result.verificationUri} and confirm code ${result.userCode}, then call connect again.`,
-        isError: true
+        m,
+        cells,
+        centroids,
+        width: w,
+        height: h,
+        finalStateDistinctiveness: distinct / (w * h)
       };
+    },
+    { frames: frames.map((frame) => frame.base64), analysisWidth: ANALYSIS_WIDTH }
+  );
+}
+
+// src/mcp/text-census.ts
+function textCensusEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env.IMPRACTICAL_TEXT_CENSUS?.trim() ?? "");
+}
+var READING_TARGET_MIN_PX = 30;
+var CANDIDATE_MIN_PX = 11;
+var isReadingTarget = (block) => block.fontSize >= READING_TARGET_MIN_PX && block.text.trim().length >= 3;
+function eyebrowPairs(blocks) {
+  const out = [];
+  for (const small of blocks) {
+    if (small.fontSize < CANDIDATE_MIN_PX) continue;
+    for (const large of blocks) {
+      if (large === small) continue;
+      if (large.fontSize < READING_TARGET_MIN_PX) continue;
+      if (small.fontSize > large.fontSize * 0.55) continue;
+      const gap = large.y - (small.y + small.height);
+      if (gap < -small.height * 0.5 || gap > small.height * 2) continue;
+      const overlap = Math.min(small.x + small.width, large.x + large.width) - Math.max(small.x, large.x);
+      if (overlap < Math.min(small.width, large.width) * 0.3) continue;
+      out.push({ small, large });
+    }
+  }
+  return out;
+}
+function spans(samples, holds) {
+  const out = [];
+  let open = null;
+  for (const sample of samples) {
+    if (holds(sample)) {
+      if (open) open.end = sample.time;
+      else open = { start: sample.time, end: sample.time, example: sample };
+    } else if (open) {
+      out.push(open);
+      open = null;
+    }
+  }
+  if (open) out.push(open);
+  return out;
+}
+var snippet = (block) => `"${block.text.trim().slice(0, 30)}${block.text.trim().length > 30 ? "\u2026" : ""}"`;
+function textCensusReport(rawSamples) {
+  if (!rawSamples.length) return "";
+  const samples = rawSamples.map((sample) => ({
+    time: sample.time,
+    blocks: sample.blocks.filter((block) => block.inViewport)
+  }));
+  const lines = [];
+  const maxTargets = Math.max(...samples.map((s) => s.blocks.filter(isReadingTarget).length));
+  lines.push(
+    `TEXT CENSUS (visible text \u2265${READING_TARGET_MIN_PX}px counts as a reading target; proxy, not OCR):`
+  );
+  lines.push(`  max simultaneous reading targets: ${maxTargets}`);
+  const multi = spans(samples, (s) => s.blocks.filter(isReadingTarget).length >= 2);
+  if (multi.length) {
+    lines.push("  \u22652 simultaneous reading targets \u2014 the viewer has more than one thing to read:");
+    for (const span of multi) {
+      const targets = span.example.blocks.filter(isReadingTarget);
+      lines.push(
+        `    ${span.start.toFixed(2)}\u2013${span.end.toFixed(2)}s: ` + targets.slice(0, 3).map(snippet).join(" + ")
+      );
     }
-    try {
-      const snapshot = await ctx.invoke(
-        "workspace-bootstrap"
+  }
+  const eyebrow = spans(samples, (s) => eyebrowPairs(s.blocks).length > 0);
+  if (eyebrow.length) {
+    lines.push("  eyebrow/subline stacks (small text riding a larger block):");
+    for (const span of eyebrow) {
+      const pair = eyebrowPairs(span.example.blocks)[0];
+      lines.push(
+        `    ${span.start.toFixed(2)}\u2013${span.end.toFixed(2)}s: ${snippet(pair.small)} stacked on ${snippet(pair.large)}`
       );
-      return {
-        text: `Connected to workspace ${snapshot.orgId}` + (snapshot.hasAccess ? "." : " \u2014 but it has no active access; check billing in the web app.")
-      };
-    } catch (error51) {
-      const message = error51 instanceof Error ? error51.message : String(error51);
-      return {
-        text: `Credential saved, but the workspace check failed: ${message}`,
-        isError: true
-      };
     }
   }
-};
-var isNotConnected = (message) => /Not connected|Not configured/i.test(message);
-
-// src/mcp/motion-context.ts
-var motionContextTool = {
-  name: "motion_context",
-  title: "Study the motion library",
-  description: "Retrieve the current versioned house skills, relevant templates, selected production reference sources, and rendered style frames for this brief. CALL THIS after engine_types and before create_video. The library is fetched live, so newly deployed motion patterns are available without updating this MCP package.",
-  inputSchema: {
-    brief: external_exports.string().min(1).describe("What the video should communicate and how it should feel."),
-    styleId: external_exports.string().optional().describe("Optional style id from a previous motion_context result."),
-    templateId: external_exports.string().optional().describe("Optional template id to study in detail."),
-    brandSlug: external_exports.string().optional().describe("Brand kit slug when this video is for a known brand. Personalizes the result."),
-    contentType: external_exports.string().optional().describe("Kind of video, e.g. 'launch-promo', 'logo-sting', 'product-demo'."),
-    detail: external_exports.enum(["focused", "full"]).optional().describe("Focused returns selected references. Full also exposes all shared source references."),
-    includeReferenceFrames: external_exports.boolean().optional().describe("Render four frames from the best matching production reference. Default true.")
-  },
-  local: true,
+  if (!multi.length && !eyebrow.length) {
+    lines.push("  clean: one reading target at a time, no eyebrow stacks.");
+  } else {
+    lines.push(
+      "  One reading target at a time. Text either performs (kinetic emphasis in the type) or states a claim the very next moment proves on screen \u2014 never a caption running beside something else."
+    );
+  }
+  return lines.join("\n");
+}
+async function sampleTextBlocks(page, minFontPx) {
+  return page.evaluate((minPx) => {
+    const out = [];
+    const viewportWidth = window.innerWidth;
+    const viewportHeight = window.innerHeight;
+    for (const el of Array.from(document.body.querySelectorAll("*"))) {
+      const direct = Array.from(el.childNodes).filter((node) => node.nodeType === Node.TEXT_NODE).map((node) => node.textContent ?? "").join("").trim();
+      if (!direct) continue;
+      const style = getComputedStyle(el);
+      const fontSize = parseFloat(style.fontSize);
+      if (!Number.isFinite(fontSize) || fontSize < minPx) continue;
+      if (style.visibility === "hidden" || style.display === "none") continue;
+      if (parseFloat(style.opacity) < 0.05) continue;
+      const rect = el.getBoundingClientRect();
+      if (rect.width < 2 || rect.height < 2) continue;
+      const inViewport = !(rect.bottom < 0 || rect.right < 0 || rect.top > viewportHeight || rect.left > viewportWidth);
+      const margin = 0.02 * Math.min(viewportWidth, viewportHeight);
+      const fullyInFrame = rect.left >= margin && rect.top >= margin && rect.right <= viewportWidth - margin && rect.bottom <= viewportHeight - margin;
+      let selector;
+      for (const attr of Array.from(el.attributes)) {
+        if (attr.name.startsWith("data-") && !attr.name.startsWith("data-studio-")) {
+          selector = "[" + attr.name + "]";
+          break;
+        }
+      }
+      out.push({
+        text: direct.slice(0, 40),
+        fontSize,
+        x: rect.x,
+        y: rect.y,
+        width: rect.width,
+        height: rect.height,
+        inViewport,
+        fullyInFrame,
+        selector
+      });
+    }
+    return out;
+  }, minFontPx);
+}
+function textContractEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env.IMPRACTICAL_TEXT_CONTRACT?.trim() ?? "");
+}
+function inspectV2Enabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env.IMPRACTICAL_INSPECT_V2?.trim() ?? "");
+}
+var STATEMENT_MIN_FRACTION = 0.1;
+var PROOF_TEXT_MIN_FRACTION = 0.025;
+var EDITORIAL_MIN_FONT_PX = 24;
+var WITNESS_SCALE_FRACTION = 0.04;
+var MIN_WITNESS_SECONDS = 0.9;
+var STATEMENT_HOLD_SECONDS = 1.2;
+var RIDING_DIFF_THRESHOLD = 0.05;
+var normalize = (text) => text.trim().replace(/\s+/g, " ");
+var settledBetween = (a, b, frameDiagonal) => Math.hypot(a.x + a.width / 2 - (b.x + b.width / 2), a.y + a.height / 2 - (b.y + b.height / 2)) < frameDiagonal * 0.01;
+var ICON_GLYPHS = /^[\s\u2190-\u21FF\u27F0-\u27FF\u2794-\u27BF\u2713\u2714\u2705\u2717\u2718\u2716\u274C\u25B6\u25C0\u25B2\u25BC\u2605\u2606\u2B50]+$|^\s*(->|=>|<-|<=|\[x\]|\[ \])\s*$/;
+function analyzeTextContract(input) {
+  const { samples, diffs, frameWidth, frameHeight, stepSeconds } = input;
+  const diagonal = Math.hypot(frameWidth, frameHeight);
+  const findings = [];
+  const lines = /* @__PURE__ */ new Map();
+  let previous = /* @__PURE__ */ new Map();
+  for (const [index, sample] of samples.entries()) {
+    const current = /* @__PURE__ */ new Map();
+    for (const block of sample.blocks) {
+      if (block.fontSize < EDITORIAL_MIN_FONT_PX) continue;
+      const key = normalize(block.text);
+      if (key.length < 3) continue;
+      current.set(key, block);
+      let stat = lines.get(key);
+      if (!stat) {
+        stat = { text: key, witnessedSeconds: 0, everInViewport: false, everFullyInFrame: false, maxHeightFraction: 0, firstSeen: sample.time, ridingRun: 0, ridingFlagged: false };
+        lines.set(key, stat);
+      }
+      if (block.inViewport) {
+        stat.maxHeightFraction = Math.max(stat.maxHeightFraction, block.height / frameHeight);
+      }
+      const prior = previous.get(key);
+      const settled = prior ? settledBetween(prior, block, diagonal) : false;
+      const atScale = block.height >= frameHeight * WITNESS_SCALE_FRACTION;
+      if (block.inViewport) {
+        stat.everInViewport = true;
+        if (block.fullyInFrame) stat.everFullyInFrame = true;
+        if (settled && atScale && block.fullyInFrame) stat.witnessedSeconds += stepSeconds;
+      }
+      const acting = index < diffs.length && diffs[index] >= RIDING_DIFF_THRESHOLD;
+      if (block.inViewport && settled && atScale && acting) {
+        stat.ridingRun += 1;
+        if (stat.ridingRun >= 3 && !stat.ridingFlagged) {
+          stat.ridingFlagged = true;
+          findings.push({
+            kind: "riding",
+            detail: `"${stat.text.slice(0, 30)}" rests in frame while the product is acting around ${sample.time.toFixed(2)}s \u2014 text and action are competing; give the claim its own moment, or let the product push it out.`
+          });
+        }
+      } else {
+        stat.ridingRun = 0;
+      }
+    }
+    previous = current;
+  }
+  const lockedLines = input.lockedContent?.map((line) => line.text);
+  if (lockedLines?.length) {
+    const locked = lockedLines.map(normalize);
+    const matches = (observed) => locked.some((line) => line.startsWith(observed) || observed.startsWith(line));
+    for (const stat of lines.values()) {
+      if (stat.maxHeightFraction < WITNESS_SCALE_FRACTION) continue;
+      if (!matches(stat.text)) {
+        findings.push({
+          kind: "unauthorized",
+          detail: `"${stat.text.slice(0, 30)}" appears on screen at editorial scale but is NOT in the locked content \u2014 execution may not invent lines the viewer is asked to read. Remove it, shrink it into product texture, or revise the content artifact deliberately.`
+        });
+      }
+    }
+    for (const line of locked) {
+      const seen = [...lines.values()].some(
+        (stat) => line.startsWith(stat.text) || stat.text.startsWith(line)
+      );
+      if (!seen) {
+        findings.push({
+          kind: "missing",
+          detail: `Locked line "${line.slice(0, 30)}" never appears in the film \u2014 a planned beat is silent.`
+        });
+      }
+    }
+  }
+  if (samples.length) {
+    const openers = samples[0].blocks.filter(
+      (block) => block.inViewport && block.fontSize >= EDITORIAL_MIN_FONT_PX && normalize(block.text).length >= 3
+    );
+    const firstLocked = lockedLines?.length ? normalize(lockedLines[0]) : null;
+    for (const [index, block] of openers.entries()) {
+      const text = normalize(block.text);
+      const isDeclaredOpening = firstLocked ? firstLocked.startsWith(text) || text.startsWith(firstLocked) : index === 0 && openers.length === 1;
+      if (!isDeclaredOpening && (firstLocked || openers.length > 1)) {
+        findings.push({
+          kind: "frame0-leak",
+          detail: `"${text.slice(0, 30)}" is visible at frame 0 but is not the film's opening \u2014 a later element is leaking its initial state. Hide it statically (App.tsx or gsap.set in setup); a from() tween does not hide anything on a cold seek.`
+        });
+      }
+    }
+  }
+  const INFLATED_RATIO = 2.5;
+  const lockedLabels = (input.lockedContent ?? []).filter((line) => line.kind === "label").map((line) => normalize(line.text));
+  if (lockedLabels.length) {
+    const inflatedSeen = /* @__PURE__ */ new Set();
+    for (const sample of samples) {
+      const productSizes = sample.blocks.filter(
+        (block) => block.inViewport && block.fontSize >= CANDIDATE_MIN_PX && block.height < frameHeight * WITNESS_SCALE_FRACTION
+      ).map((block) => block.fontSize).sort((a, b) => a - b);
+      if (productSizes.length < 5) continue;
+      const nativeScale = productSizes[Math.floor(productSizes.length / 2)];
+      for (const block of sample.blocks) {
+        if (!block.inViewport || block.height < frameHeight * WITNESS_SCALE_FRACTION) continue;
+        const key = normalize(block.text);
+        if (!key || inflatedSeen.has(key)) continue;
+        const isLabel = lockedLabels.some(
+          (line) => line.startsWith(key) || key.startsWith(line)
+        );
+        if (!isLabel) continue;
+        if (block.fontSize > nativeScale * INFLATED_RATIO) {
+          inflatedSeen.add(key);
+          findings.push({
+            kind: "inflated",
+            detail: `"${block.text.slice(0, 40)}" renders at ${Math.round(block.fontSize)}px inside UI whose native type scale is ~${Math.round(nativeScale)}px (${(block.fontSize / nativeScale).toFixed(1)}x) at ${sample.time.toFixed(2)}s. A product element never exceeds its native proportion \u2014 make it readable by pushing the CAMERA to it (the whole UI scales together), or restyle it as a true product toast/control at native scale.`
+          });
+        }
+      }
+    }
+  }
+  const editorialLines = input.lockedContent?.map((line) => normalize(line.text));
+  const isEditorial = (observed) => !editorialLines?.length || editorialLines.some((line) => line.startsWith(observed) || observed.startsWith(line));
+  const glyphSeen = /* @__PURE__ */ new Set();
+  for (const sample of samples) {
+    for (const block of sample.blocks) {
+      const text = block.text.trim();
+      if (!text || block.fontSize < CANDIDATE_MIN_PX) continue;
+      if (!ICON_GLYPHS.test(text) || glyphSeen.has(text)) continue;
+      glyphSeen.add(text);
+      findings.push({
+        kind: "glyph-icon",
+        detail: `"${text}" is a text glyph doing an icon's job. Use the real icon from lucide-react (import { ArrowRight, Check } from 'lucide-react') \u2014 a glyph inherits the text font, so it sits on the baseline at the wrong weight and optical size, and it cannot take a stroke width or animate as its own element.`
+      });
+    }
+  }
+  const stackedSeen = /* @__PURE__ */ new Set();
+  for (const sample of samples) {
+    for (const editorial of sample.blocks) {
+      if (!editorial.inViewport) continue;
+      if (editorial.height < frameHeight * WITNESS_SCALE_FRACTION) continue;
+      const key = normalize(editorial.text);
+      if (!key || stackedSeen.has(key)) continue;
+      const margin = frameHeight * 0.02;
+      const overlapped = sample.blocks.filter((other) => {
+        if (other === editorial || !other.inViewport) return false;
+        if (normalize(other.text) === key) return false;
+        return editorial.x - margin < other.x + other.width && other.x < editorial.x + editorial.width + margin && editorial.y - margin < other.y + other.height && other.y < editorial.y + editorial.height + margin;
+      });
+      if (overlapped.length) {
+        stackedSeen.add(key);
+        findings.push({
+          kind: "stacked",
+          detail: `"${editorial.text.slice(0, 40)}" is stacked on or crowding other readable text at ${sample.time.toFixed(2)}s (e.g. "${overlapped[0].text.slice(0, 30)}"${overlapped.length > 1 ? ` and ${overlapped.length - 1} more` : ""}). A claim and the product may never share the same space \u2014 dimming the product under the words is not separation. Clear the product fully (or hide it) while the claim is up, then bring it back for the proof.`
+        });
+      }
+    }
+  }
+  for (const stat of lines.values()) {
+    if (!stat.everInViewport) {
+      findings.push({
+        kind: "off-camera",
+        detail: `"${stat.text.slice(0, 30)}" (from ${stat.firstSeen.toFixed(2)}s) exists on the stage but the camera NEVER shows it \u2014 the viewer never sees this line. If it explains an action, that action happens unexplained.`
+      });
+    } else if (stat.maxHeightFraction < WITNESS_SCALE_FRACTION && isEditorial(stat.text)) {
+      findings.push({
+        kind: "too-small",
+        detail: `"${stat.text.slice(0, 30)}" peaks at ${(stat.maxHeightFraction * 100).toFixed(1)}% of frame height \u2014 below the ${(WITNESS_SCALE_FRACTION * 100).toFixed(0)}% readable floor (statements are 10-15% per line). This is an editorial line the viewer is asked to read: make it bigger or push the camera to it. Do NOT solve it by deleting the words \u2014 product content is allowed to be small.`
+      });
+    } else if (!stat.everFullyInFrame) {
+      findings.push({
+        kind: "clipped",
+        detail: `"${stat.text.slice(0, 30)}" only ever appears partially cut off by the frame edge \u2014 the viewer cannot read a clipped line. Reframe the camera or reposition the text so it sits fully inside the frame with a margin.`
+      });
+    } else if (stat.witnessedSeconds < MIN_WITNESS_SECONDS) {
+      findings.push({
+        kind: "unwitnessed",
+        detail: `"${stat.text.slice(0, 30)}" is on camera settled and readable for only ${stat.witnessedSeconds.toFixed(2)}s (needs ~${MIN_WITNESS_SECONDS}s) \u2014 the viewer cannot read it. Give it a real held moment before its action.`
+      });
+    } else {
+      const isStatement = (input.lockedContent ?? []).some(
+        (line) => line.kind === "statement" && (normalize(line.text).startsWith(stat.text) || stat.text.startsWith(normalize(line.text)))
+      );
+      if (isStatement && stat.witnessedSeconds < STATEMENT_HOLD_SECONDS) {
+        findings.push({
+          kind: "rushed",
+          detail: `"${stat.text.slice(0, 40)}" holds for only ${stat.witnessedSeconds.toFixed(2)}s \u2014 slow down, the viewer won't be able to focus. A statement needs at least ${STATEMENT_HOLD_SECONDS}s of settled, undisturbed time before the next change.`
+        });
+      }
+    }
+  }
+  if (input.inspectV2) {
+    if (input.lockedContent?.length) {
+      const bigKinds = input.lockedContent.filter((line) => line.kind !== "label");
+      for (const line of bigKinds) {
+        const key = normalize(line.text);
+        const stat = [...lines.values()].find(
+          (candidate) => key.startsWith(candidate.text) || candidate.text.startsWith(key)
+        );
+        if (stat && stat.everFullyInFrame && stat.maxHeightFraction < STATEMENT_MIN_FRACTION) {
+          findings.push({
+            kind: "statement-small",
+            detail: `"${key.slice(0, 30)}" is a ${line.kind} but peaks at ${(stat.maxHeightFraction * 100).toFixed(1)}% of frame height \u2014 statements are 10-15% per line. Make it the biggest thing on screen.`
+          });
+        }
+      }
+    }
+    let runStart = -1;
+    let runMax = 0;
+    const closeRun = (endTime) => {
+      if (runStart >= 0 && endTime - runStart >= 1.5 && runMax > 0 && runMax < PROOF_TEXT_MIN_FRACTION) {
+        findings.push({
+          kind: "proof-text-small",
+          detail: `proof window ${runStart.toFixed(2)}-${endTime.toFixed(2)}s: product text peaks at ${(runMax * 100).toFixed(1)}% rendered \u2014 if the viewer must read it, zoom until it clears ${(PROOF_TEXT_MIN_FRACTION * 100).toFixed(1)}%.`
+        });
+      }
+      runStart = -1;
+      runMax = 0;
+    };
+    for (const sample of samples) {
+      const visible = sample.blocks.filter((block) => block.inViewport);
+      const editorial = visible.some((block) => block.fontSize >= EDITORIAL_MIN_FONT_PX);
+      const product = visible.filter((block) => block.fontSize < EDITORIAL_MIN_FONT_PX);
+      if (!editorial && product.length) {
+        if (runStart < 0) runStart = sample.time;
+        runMax = Math.max(runMax, ...product.map((block) => block.height / frameHeight));
+      } else {
+        closeRun(sample.time);
+      }
+    }
+    closeRun(samples.length ? samples[samples.length - 1].time : 0);
+  }
+  return findings;
+}
+function formatTextContractReport(findings) {
+  const lines = ["TEXT CONTRACT (witness + baton checks on editorial copy):"];
+  if (!findings.length) {
+    lines.push("  clean: every line is witnessed on camera, and no text rests in frame while the product acts.");
+    return lines.join("\n");
+  }
+  for (const finding of findings) lines.push(`  [${finding.kind}] ${finding.detail}`);
+  lines.push(
+    "  Rule of thumb: if the camera did not see a line, it did not happen. A claim gets the frame to itself; the product gets the frame to itself; they overlap only while one is entering, leaving, or dimmed to the background."
+  );
+  return lines.join("\n");
+}
+
+// src/mcp/motion.ts
+var MOTION_LAB_ENV = "IMPRACTICAL_MOTION_LAB";
+function motionLabEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env[MOTION_LAB_ENV]?.trim() ?? "");
+}
+var DEFAULT_EVERY_NTH_FRAME = 5;
+var MAX_SAMPLES = 48;
+var REVIEW_MAX_SAMPLES = 160;
+var QUICK_EVERY_NTH_FRAME = 10;
+var QUICK_MAX_SAMPLES = 24;
+function defaultDetail(env = process.env) {
+  const value = env.IMPRACTICAL_MOTION_DETAIL?.trim().toLowerCase();
+  return value === "full" || value === "quick" ? value : void 0;
+}
+function motionPassPlan(args) {
+  const full = args.finalReview || (args.detail ?? defaultDetail()) === "full";
+  if (full) {
+    return {
+      everyNthFrame: args.finalReview ? Math.min(Number(args.everyNthFrame ?? DEFAULT_EVERY_NTH_FRAME), DEFAULT_EVERY_NTH_FRAME) : Number(args.everyNthFrame ?? DEFAULT_EVERY_NTH_FRAME),
+      maxSamples: args.finalReview ? REVIEW_MAX_SAMPLES : MAX_SAMPLES,
+      includeSheets: true,
+      includeCatalog: true
+    };
+  }
+  return {
+    everyNthFrame: Number(args.everyNthFrame ?? QUICK_EVERY_NTH_FRAME),
+    maxSamples: QUICK_MAX_SAMPLES,
+    includeSheets: false,
+    includeCatalog: false
+  };
+}
+var DEAD_THRESHOLD = 5e-3;
+var IMPERCEPTIBLE_THRESHOLD = 0.01;
+function sampleTimes(input) {
+  const maxSamples = Math.max(2, input.maxSamples ?? MAX_SAMPLES);
+  const span = Math.max(0, input.to - input.from);
+  const round = (value) => Math.round(value * 1e3) / 1e3;
+  if (span === 0) return { times: [round(input.from)], stepSeconds: 0, coarsened: false };
+  const stepFrames = Math.max(1, Math.round(input.everyNthFrame));
+  const step = stepFrames / Math.max(1, input.fps);
+  const naturalCount = Math.floor(span / step + 1e-9) + 1;
+  if (naturalCount > maxSamples) {
+    const coarseStep = span / (maxSamples - 1);
+    return {
+      times: Array.from({ length: maxSamples }, (_, i) => round(input.from + i * coarseStep)),
+      stepSeconds: coarseStep,
+      coarsened: true
+    };
+  }
+  const times = Array.from({ length: naturalCount }, (_, i) => round(input.from + i * step));
+  if (times[times.length - 1] < round(input.to)) times.push(round(input.to));
+  return { times, stepSeconds: step, coarsened: false };
+}
+function buildIntervals(times, diffs) {
+  return diffs.map((changed, i) => ({ start: times[i], end: times[i + 1], changed }));
+}
+var SETTLE_THRESHOLD = 0.02;
+var BREATHLESS_MAX_RUN_SECONDS = 3.5;
+var ACTION_CLUSTER_SECONDS = 0.2;
+var ACTION_MAX_TWEEN_SECONDS = 3;
+var ACTION_WINDOW_SECONDS = 6;
+var ACTION_WINDOW_MAX = 5;
+function actionEvents(tweens) {
+  const starts = tweens.filter((tween) => tween.end - tween.start <= ACTION_MAX_TWEEN_SECONDS).map((tween) => tween.start).sort((a, b) => a - b);
+  const events = [];
+  for (const start of starts) {
+    if (!events.length || start - events[events.length - 1] > ACTION_CLUSTER_SECONDS) {
+      events.push(start);
+    }
+  }
+  return events;
+}
+function cadenceMoments(tweens) {
+  const events = actionEvents(tweens);
+  const moments = [];
+  for (let i = 0; i < events.length; i += 1) {
+    let j = i;
+    while (j + 1 < events.length && events[j + 1] - events[i] <= ACTION_WINDOW_SECONDS) j += 1;
+    const actions = j - i + 1;
+    if (actions > ACTION_WINDOW_MAX) {
+      const last = moments[moments.length - 1];
+      if (last && events[i] <= last.end) {
+        last.end = events[j];
+        last.actions = Math.max(last.actions, actions);
+      } else {
+        moments.push({ start: events[i], end: events[j], actions });
+      }
+    }
+  }
+  return moments;
+}
+function breathlessSpans(intervals, options = {}) {
+  const settle = options.settle ?? SETTLE_THRESHOLD;
+  const maxRun = options.maxRun ?? BREATHLESS_MAX_RUN_SECONDS;
+  const spans2 = [];
+  let runStart = null;
+  for (const interval of intervals) {
+    if (interval.changed >= settle) {
+      runStart ??= interval.start;
+      if (interval.end - runStart > maxRun) {
+        const last = spans2[spans2.length - 1];
+        if (last && last.start === runStart) last.end = interval.end;
+        else spans2.push({ start: runStart, end: interval.end });
+      }
+    } else {
+      runStart = null;
+    }
+  }
+  return spans2;
+}
+function deadAirSpans(intervals, options = {}) {
+  const threshold = options.threshold ?? DEAD_THRESHOLD;
+  const minSpan = options.minSpanSeconds ?? 0.6;
+  const spans2 = [];
+  let open = null;
+  for (const interval of intervals) {
+    if (interval.changed < threshold) {
+      if (open) open.end = interval.end;
+      else open = { start: interval.start, end: interval.end };
+    } else if (open) {
+      spans2.push(open);
+      open = null;
+    }
+  }
+  if (open) spans2.push(open);
+  return spans2.filter((span) => span.end - span.start >= minSpan);
+}
+function imperceptibleTweens(tweens, intervals, options = {}) {
+  const minDuration = options.minDurationSeconds ?? 0.5;
+  const threshold = options.threshold ?? IMPERCEPTIBLE_THRESHOLD;
+  return tweens.filter((tween) => {
+    if (tween.end - tween.start < minDuration) return false;
+    const active = intervals.filter(
+      (interval) => interval.end > tween.start && interval.start < tween.end
+    );
+    if (!active.length) return false;
+    const mean2 = active.reduce((sum, interval) => sum + interval.changed, 0) / active.length;
+    return mean2 < threshold;
+  });
+}
+var formatTime = (value) => value.toFixed(2);
+var bar = (changed) => {
+  const filled = Math.round(Math.min(changed / 0.25, 1) * 10);
+  return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+};
+var describeTween = (tween) => {
+  const targets = tween.targets.slice(0, 3).join(", ") + (tween.targets.length > 3 ? ", \u2026" : "");
+  const props = tween.props.slice(0, 4).join(",") + (tween.props.length > 4 ? ",\u2026" : "");
+  if (tween.end - tween.start < 0.02) {
+    return `${formatTime(tween.start)}s        SET ${targets}  ${props} (hard cut)`;
+  }
+  return `${formatTime(tween.start)}\u2192${formatTime(tween.end)}s  ${targets}  ${props}  ease=${tween.ease}`;
+};
+var FOCAL_GRID_COLS = 8;
+var FOCAL_GRID_ROWS = 6;
+var FOCAL_CELL_THRESHOLD = 0.15;
+var FOCAL_BUDGET = 2;
+function focalClusters(cells, cols = FOCAL_GRID_COLS, rows = FOCAL_GRID_ROWS, threshold = FOCAL_CELL_THRESHOLD) {
+  const active = cells.map((cell) => cell >= threshold);
+  const seen = new Array(cells.length).fill(false);
+  let clusters = 0;
+  for (let start = 0; start < cells.length; start += 1) {
+    if (!active[start] || seen[start]) continue;
+    clusters += 1;
+    const stack = [start];
+    seen[start] = true;
+    while (stack.length) {
+      const index = stack.pop();
+      const x = index % cols;
+      const y = Math.floor(index / cols);
+      for (const [nx, ny] of [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]]) {
+        if (nx < 0 || ny < 0 || nx >= cols || ny >= rows) continue;
+        const neighbour = ny * cols + nx;
+        if (active[neighbour] && !seen[neighbour]) {
+          seen[neighbour] = true;
+          stack.push(neighbour);
+        }
+      }
+    }
+  }
+  return clusters;
+}
+function splitFocusMoments(times, cellDiffs, budget = FOCAL_BUDGET) {
+  const moments = [];
+  for (const [i, cells] of cellDiffs.entries()) {
+    const clusters = focalClusters(cells);
+    if (clusters > budget) {
+      moments.push({ start: times[i], end: times[i + 1], clusters });
+    }
+  }
+  return moments;
+}
+function motionReport(input) {
+  const { intervals, tweens, plan } = input;
+  const lines = [];
+  lines.push(
+    `MOTION ANALYSIS ${formatTime(input.from)}\u2013${formatTime(input.to)}s of ${formatTime(input.duration)}s \u2014 ${plan.times.length} samples, ${plan.stepSeconds.toFixed(3)}s apart` + (plan.coarsened ? ` (coarsened to fit ${plan.times.length} samples \u2014 analyze a narrower window for every-${input.everyNthFrame}-frames density)` : ` (every ${input.everyNthFrame} frames)`) + "."
+  );
+  lines.push(
+    "Read the contact sheets like a director: adjacent tiles are one step apart, so the difference between them IS the motion. A row of near-identical tiles is a freeze."
+  );
+  lines.push("");
+  lines.push("Pixel change per interval (fraction of the frame that moved; <0.5% reads as frozen):");
+  for (const interval of intervals) {
+    lines.push(
+      `  ${formatTime(interval.start)}\u2013${formatTime(interval.end)}  ${bar(interval.changed)} ${(interval.changed * 100).toFixed(1)}%`
+    );
+  }
+  const dead = deadAirSpans(intervals);
+  lines.push("");
+  if (dead.length) {
+    lines.push("DEAD AIR \u2014 nothing perceptible moves. Decide what should own this time:");
+    for (const span of dead) {
+      lines.push(
+        `  ${formatTime(span.start)}\u2013${formatTime(span.end)}s (${(span.end - span.start).toFixed(2)}s)`
+      );
+    }
+  } else {
+    lines.push("DEAD AIR: none in this window.");
+  }
+  if (input.breathless) {
+    lines.push("");
+    if (input.breathless.length) {
+      lines.push(
+        "TOO FAST \u2014 slow down, the viewer won't be able to focus. These spans never stop moving; nothing holds long enough to be taken in. Let each thing land and sit before the next change:"
+      );
+      for (const span of input.breathless.slice(0, 6)) {
+        lines.push(
+          `  ${formatTime(span.start)}\u2013${formatTime(span.end)}s (${(span.end - span.start).toFixed(1)}s of nonstop change)`
+        );
+      }
+    } else {
+      lines.push("PACING: motion settles regularly \u2014 the viewer gets time to focus.");
+    }
+  }
+  if (input.cadence) {
+    lines.push("");
+    if (input.cadence.length) {
+      lines.push(
+        "ACTIONS TOO FREQUENT \u2014 slow down, the viewer won't be able to focus. The house cadence is about one action every 1\u20131.5 seconds; these stretches pack them faster:"
+      );
+      for (const moment of input.cadence.slice(0, 6)) {
+        lines.push(
+          `  ${formatTime(moment.start)}\u2013${formatTime(moment.end)}s: ${moment.actions} actions in ${(moment.end - moment.start).toFixed(1)}s`
+        );
+      }
+    } else {
+      lines.push("ACTION CADENCE: about one action at a time \u2014 the viewer can follow.");
+    }
+  }
+  if (input.splitFocus) {
+    lines.push("");
+    if (input.splitFocus.length) {
+      lines.push(
+        `FOCAL BUDGET BLOWN \u2014 more than ${FOCAL_BUDGET} separate regions of the frame are moving at once. The eye can follow one focal point; everything else moving beside it is noise. Let one change finish (or hold) before the next begins:`
+      );
+      for (const moment of input.splitFocus.slice(0, 8)) {
+        lines.push(
+          `  ${formatTime(moment.start)}\u2013${formatTime(moment.end)}  ${moment.clusters} regions moving simultaneously`
+        );
+      }
+      if (input.splitFocus.length > 8) {
+        lines.push(`  \u2026and ${input.splitFocus.length - 8} more intervals over budget`);
+      }
+    } else {
+      lines.push("FOCAL BUDGET: respected \u2014 at most one focal change at a time in this window.");
+    }
+  }
+  lines.push("");
+  if (tweens === null) {
+    lines.push(
+      "TIMELINE: introspection unavailable \u2014 this preview bundle predates window.__timeline. Save the draft again to rebuild with a current bundle."
+    );
+  } else if (!tweens.length) {
+    lines.push("TIMELINE: no tweens found in this window.");
+  } else {
+    const flagged = new Set(imperceptibleTweens(tweens, intervals));
+    lines.push("TIMELINE \u2014 the tweens actually scheduled in this window (absolute seconds):");
+    for (const tween of [...tweens].sort((a, b) => a.start - b.start)) {
+      const flag = flagged.has(tween) ? "  \u26A0 runs but changes almost no pixels \u2014 likely an imperceptible magnitude; make it visibly larger or give the time to something else" : "";
+      lines.push(`  ${describeTween(tween)}${flag}`);
+    }
+    const covered = intervals.filter(
+      (interval) => tweens.some((tween) => tween.end > interval.start && tween.start < interval.end)
+    ).length;
+    const perceptible = intervals.filter((interval) => interval.changed >= DEAD_THRESHOLD).length;
+    lines.push("");
+    lines.push(
+      `Coverage: tweens are active in ${Math.round(covered / Math.max(1, intervals.length) * 100)}% of intervals; perceptible motion occupies ${Math.round(perceptible / Math.max(1, intervals.length) * 100)}%.`
+    );
+  }
+  return lines.join("\n");
+}
+var REFERENCE_STATIC_BAND = { low: 0.35, median: 0.45, high: 0.55 };
+function envelopeLine(intervals) {
+  if (!intervals.length) return "";
+  const still = intervals.filter((interval) => interval.changed < DEAD_THRESHOLD).length / intervals.length;
+  const delta = still - REFERENCE_STATIC_BAND.median;
+  return `REFERENCE ENVELOPE: reference launch films run ~${Math.round(REFERENCE_STATIC_BAND.low * 100)}-${Math.round(REFERENCE_STATIC_BAND.high * 100)}% static (median ~${Math.round(REFERENCE_STATIC_BAND.median * 100)}%); this window: ${(still * 100).toFixed(1)}%` + (delta > 0.1 ? ` \u2014 ${Math.round(delta * 100)} points stiller than the reference norm.` : " \u2014 inside the norm.");
+}
+function repairMenu(input) {
+  const out = [];
+  for (const span of input.deadSpans) {
+    const sample = input.textSamples?.find((candidate) => candidate.time >= span.start && candidate.time <= span.end);
+    const anchor = sample?.blocks.find((block) => block.inViewport && block.selector)?.selector;
+    out.push(
+      `REPAIR dead air ${span.start.toFixed(2)}-${span.end.toFixed(2)}s: either trim the hold (pull the next cut to ~${(span.start + 0.9).toFixed(1)}s), or give it hold-life` + (anchor ? ` \u2014 e.g. a slow camera push toward ${anchor} (ease-in-out-cubic, the full span)` : "") + ". A reading hold may rest ~1s; longer needs visible life."
+    );
+  }
+  for (const tween of input.imperceptible) {
+    out.push(
+      `REPAIR imperceptible tween ${tween.start.toFixed(2)}-${tween.end.toFixed(2)}s on ${tween.targets[0] ?? "target"} (${tween.props.slice(0, 3).join(",")}): the change is below what a viewer can see \u2014 multiply the distance roughly 5-10x, or delete it and hold clean.`
+    );
+  }
+  return out;
+}
+function beatVerdicts(beats, intervals) {
+  const out = [];
+  for (const beat of beats) {
+    const inside = intervals.filter((interval) => interval.end > beat.start && interval.start < beat.end);
+    if (!inside.length) continue;
+    const activeShare = inside.filter((interval) => interval.changed >= IMPERCEPTIBLE_THRESHOLD).length / inside.length;
+    const label = `${beat.start.toFixed(1)}-${beat.end.toFixed(1)}s "${beat.subject.slice(0, 24)}"`;
+    if (beat.energy === "high" && activeShare < 0.35) {
+      out.push(
+        `BEAT MISMATCH ${label}: declared HIGH energy but only ${(activeShare * 100).toFixed(0)}% of it moves \u2014 the declared move is not visible. Make it move or re-declare the beat honestly.`
+      );
+    } else if (beat.energy === "low" && activeShare < 0.15) {
+      out.push(`BEAT MISMATCH ${label}: declared LOW energy but is essentially frozen (${(activeShare * 100).toFixed(0)}% active).`);
+    } else if (beat.energy === "rest" && activeShare > 0.6) {
+      out.push(`BEAT NOTE ${label}: declared REST but ${(activeShare * 100).toFixed(0)}% of it moves \u2014 fine if intended, distracting if not.`);
+    }
+    const length = beat.end - beat.start;
+    if (length > 0 && length < 1.5) {
+      out.push(
+        `BEAT TOO SHORT ${label}: only ${length.toFixed(1)}s \u2014 too quick for the viewer to take in. Slow down: give it more time or fold it into the neighbouring beat.`
+      );
+    }
+  }
+  return out;
+}
+var MOTION_SCORE_ENV = "IMPRACTICAL_MOTION_SCORE";
+function motionScoreEnabled(env = process.env) {
+  return !/^(0|false|off|no)$/i.test(env[MOTION_SCORE_ENV]?.trim() ?? "");
+}
+var SCENE_SWITCH_CLUSTER_SECONDS = 0.3;
+var CUT_BOUNDARY_TOLERANCE_SECONDS = 0.35;
+var SCENE_MIN_SECONDS = 2;
+var isSceneRootToggle = (tween) => {
+  if (!tween.scene || !tween.targets.includes("[data-scene]")) return null;
+  const value = tween.values?.autoAlpha ?? tween.values?.opacity;
+  return typeof value === "number" ? value : null;
+};
+function sceneSwitches(tweens) {
+  const events = [];
+  for (const tween of tweens) {
+    const value = isSceneRootToggle(tween);
+    if (value === null || !tween.scene) continue;
+    events.push({ time: tween.end, scene: tween.scene, visible: value > 0.5 });
+  }
+  events.sort((a, b) => a.time - b.time);
+  const switches = [];
+  for (const event of events) {
+    const current = switches[switches.length - 1];
+    if (current && event.time - current.time <= SCENE_SWITCH_CLUSTER_SECONDS) {
+      if (event.visible) current.shown.push(event.scene);
+      else current.hidden.push(event.scene);
+    } else {
+      switches.push({
+        time: event.time,
+        hidden: event.visible ? [] : [event.scene],
+        shown: event.visible ? [event.scene] : []
+      });
+    }
+  }
+  return switches;
+}
+function sceneSpans(tweens, duration3) {
+  const shownAt = /* @__PURE__ */ new Map();
+  const spans2 = [];
+  const events = tweens.map((tween) => ({ tween, value: isSceneRootToggle(tween) })).filter((entry) => entry.value !== null).sort((a, b) => a.tween.end - b.tween.end);
+  for (const { tween, value } of events) {
+    if (value > 0.5) {
+      if (!shownAt.has(tween.scene)) shownAt.set(tween.scene, tween.end);
+    } else {
+      const start = shownAt.get(tween.scene);
+      if (start !== void 0) {
+        spans2.push({ scene: tween.scene, start, end: tween.end });
+        shownAt.delete(tween.scene);
+      }
+    }
+  }
+  for (const [scene, start] of shownAt) spans2.push({ scene, start, end: duration3 });
+  return spans2.sort((a, b) => a.start - b.start);
+}
+var INSTANT_SECONDS = 0.05;
+var GENERIC_MIN_TOTAL_SECONDS = 2;
+var GENERIC_MIN_LONGEST_SECONDS = 1.2;
+var GENERIC_MAX_OVERLAP_SHARE = 0.4;
+var instantAlpha = (tween) => {
+  if (tween.end - tween.start > INSTANT_SECONDS) return null;
+  const value = tween.values?.autoAlpha ?? tween.values?.opacity;
+  return typeof value === "number" ? value : null;
+};
+function buildSceneModel(tweens, duration3) {
+  const declared = sceneSwitches(tweens);
+  if (declared.length) {
+    return {
+      spans: sceneSpans(tweens, duration3),
+      switches: declared,
+      rootIds: /* @__PURE__ */ new Set(),
+      sceneOf: (tween) => tween.scene ?? null
+    };
+  }
+  const eventsByTarget = /* @__PURE__ */ new Map();
+  for (const tween of tweens) {
+    const value = instantAlpha(tween);
+    const target = tween.targets[0];
+    if (value === null || !target || target.startsWith("[data-cursor")) continue;
+    const list = eventsByTarget.get(target) ?? [];
+    list.push({ time: tween.end, visible: value > 0.5 });
+    eventsByTarget.set(target, list);
+  }
+  const candidates = [];
+  for (const [target, events2] of eventsByTarget) {
+    events2.sort((a, b) => a.time - b.time);
+    const spans3 = [];
+    let shownAt = null;
+    for (const event of events2) {
+      if (event.visible) shownAt ??= event.time;
+      else if (shownAt !== null) {
+        spans3.push({ start: shownAt, end: event.time });
+        shownAt = null;
+      }
+    }
+    if (shownAt !== null) spans3.push({ start: shownAt, end: duration3 });
+    if (!spans3.length) continue;
+    const total = spans3.reduce((sum, span) => sum + (span.end - span.start), 0);
+    const longest = Math.max(...spans3.map((span) => span.end - span.start));
+    if (total < GENERIC_MIN_TOTAL_SECONDS || longest < GENERIC_MIN_LONGEST_SECONDS) continue;
+    candidates.push({ target, spans: spans3, total });
+  }
+  candidates.sort((a, b) => b.total - a.total);
+  const accepted = [];
+  const overlap = (a, b) => Math.max(0, Math.min(a.end, b.end) - Math.max(a.start, b.start));
+  for (const candidate of candidates) {
+    let overlapping = 0;
+    for (const span of candidate.spans) {
+      for (const other of accepted) {
+        for (const otherSpan of other.spans) overlapping += overlap(span, otherSpan);
+      }
+    }
+    if (overlapping / candidate.total <= GENERIC_MAX_OVERLAP_SHARE) accepted.push(candidate);
+  }
+  const rootIds = new Set(accepted.map((candidate) => candidate.target));
+  const spans2 = accepted.flatMap((candidate) => candidate.spans.map((span) => ({ scene: candidate.target, ...span }))).sort((a, b) => a.start - b.start);
+  const events = [];
+  for (const candidate of accepted) {
+    for (const event of eventsByTarget.get(candidate.target) ?? []) {
+      events.push({ time: event.time, scene: candidate.target, visible: event.visible });
+    }
+  }
+  events.sort((a, b) => a.time - b.time);
+  const switches = [];
+  for (const event of events) {
+    const current = switches[switches.length - 1];
+    if (current && event.time - current.time <= 0.3) {
+      if (event.visible) current.shown.push(event.scene);
+      else current.hidden.push(event.scene);
+    } else {
+      switches.push({
+        time: event.time,
+        hidden: event.visible ? [] : [event.scene],
+        shown: event.visible ? [event.scene] : []
+      });
+    }
+  }
+  const sceneOf = (tween) => {
+    if (rootIds.has(tween.targets[0] ?? "")) return null;
+    const mid = (tween.start + tween.end) / 2;
+    for (const span of spans2) if (mid >= span.start && mid <= span.end) return span.scene;
+    return null;
+  };
+  return { spans: spans2, switches, rootIds, sceneOf };
+}
+var EXIT_GLYPH = {
+  squash: "S",
+  wipe: "W",
+  slide: "L",
+  fade: "F",
+  camera: "C",
+  hard: "\xB7"
+};
+var TRANSFORM_PROPS = /* @__PURE__ */ new Set(["x", "y", "xPercent", "yPercent", "scale", "scaleX", "scaleY", "rotation"]);
+function classifyExit(tweens, swtch, model) {
+  const sceneOf = (tween) => tween.scene ?? (model ? model.sceneOf(tween) : null);
+  const window2 = tweens.filter((tween) => {
+    if (tween.end <= swtch.time - 0.9 || tween.end > swtch.time + 0.15) return false;
+    if (tween.end - tween.start <= 0.01) return false;
+    if (isSceneRootToggle(tween) !== null) return false;
+    if (model?.rootIds.has(tween.targets[0] ?? "")) return false;
+    const scene = sceneOf(tween);
+    return scene !== null && swtch.hidden.includes(scene);
+  });
+  const has = (predicate) => window2.some(predicate);
+  if (has(
+    (tween) => ["scale", "scaleX", "scaleY"].some(
+      (prop) => typeof tween.values?.[prop] === "number" && tween.values[prop] <= 0.15
+    )
+  )) {
+    return "squash";
+  }
+  if (has((tween) => tween.props.some((prop) => prop.toLowerCase().includes("clippath")))) return "wipe";
+  if (has(
+    (tween) => ["x", "y"].some((prop) => typeof tween.values?.[prop] === "number" && Math.abs(tween.values[prop]) >= 120) || ["xPercent", "yPercent"].some(
+      (prop) => typeof tween.values?.[prop] === "number" && Math.abs(tween.values[prop]) >= 60
+    )
+  )) {
+    return "slide";
+  }
+  if (has((tween) => {
+    const value = tween.values?.autoAlpha ?? tween.values?.opacity;
+    return typeof value === "number" && value <= 0.1;
+  })) {
+    return "fade";
+  }
+  const cameraMoves = tweens.some(
+    (tween) => tween.scene === null && (!model || model.sceneOf(tween) === null) && tween.props.some((prop) => TRANSFORM_PROPS.has(prop)) && tween.start < swtch.time + 0.4 && tween.end > swtch.time - 0.4
+  );
+  return cameraMoves ? "camera" : "hard";
+}
+function exitProfile(tweens, model) {
+  const switches = model ? model.switches : sceneSwitches(tweens);
+  return switches.filter((swtch) => swtch.hidden.length > 0).map((swtch) => ({ time: swtch.time, mechanism: classifyExit(tweens, swtch, model) }));
+}
+function exitMonotonyFlags(exits) {
+  const flags = [];
+  let runStart = 0;
+  for (let i = 1; i <= exits.length; i += 1) {
+    if (i === exits.length || exits[i].mechanism !== exits[runStart].mechanism) {
+      const runLength = i - runStart;
+      if (runLength >= 3 && exits[runStart].mechanism !== "camera") {
+        const times = exits.slice(runStart, i).map((exit) => `${exit.time.toFixed(1)}s`).join(", ");
+        flags.push(
+          `EXIT MONOTONY: ${runLength} consecutive '${exits[runStart].mechanism}' exits (${times}) \u2014 the same leave-the-stage move back to back reads as a loop.`
+        );
+      }
+      runStart = i;
+    }
+  }
+  if (exits.length >= 4) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const exit of exits) counts.set(exit.mechanism, (counts.get(exit.mechanism) ?? 0) + 1);
+    const [topMechanism, topCount] = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
+    if (topCount / exits.length > 0.5 && topMechanism !== "camera") {
+      flags.push(
+        `EXIT MONOTONY: '${topMechanism}' is ${topCount} of ${exits.length} exits \u2014 one mechanism is carrying the whole film.`
+      );
+    }
+  }
+  return flags;
+}
+function cutAlignment(cutTimes, beats) {
+  const boundaries = [...new Set(beats.flatMap((beat) => [beat.start, beat.end]))].sort((a, b) => a - b);
+  return cutTimes.map((time3) => {
+    if (!boundaries.length) return { time: time3, aligned: true, nearest: null };
+    const nearest = boundaries.reduce(
+      (best, boundary) => Math.abs(boundary - time3) < Math.abs(best - time3) ? boundary : best
+    );
+    return { time: time3, aligned: Math.abs(nearest - time3) <= CUT_BOUNDARY_TOLERANCE_SECONDS, nearest };
+  });
+}
+var DEBT_MIN_SECONDS = 1.2;
+function displacementDebt(tweens, duration3, model = buildSceneModel(tweens, duration3)) {
+  const spans2 = model.spans;
+  const endOfScene = /* @__PURE__ */ new Map();
+  for (const span of spans2) endOfScene.set(span.scene, Math.max(endOfScene.get(span.scene) ?? 0, span.end));
+  const states = /* @__PURE__ */ new Map();
+  for (const tween of [...tweens].sort((a, b) => a.end - b.end)) {
+    if (isSceneRootToggle(tween) !== null) continue;
+    const scene = tween.scene ?? model.sceneOf(tween);
+    if (!scene) continue;
+    const target = tween.targets[0];
+    if (!target || target.startsWith("[data-cursor") || model.rootIds.has(target)) continue;
+    const key = `${scene}\0${target}`;
+    const state = states.get(key) ?? { values: /* @__PURE__ */ new Map(), lastMove: 0, exited: false };
+    const alphaValue = tween.values?.autoAlpha ?? tween.values?.opacity;
+    const isEntrance = typeof alphaValue === "number" && alphaValue > 0.5;
+    for (const prop of tween.props) {
+      if (tween.yoyo || isEntrance) break;
+      if (TRANSFORM_PROPS.has(prop) && typeof tween.values?.[prop] === "number") {
+        state.values.set(prop, tween.values[prop]);
+        state.lastMove = tween.end;
+      }
+    }
+    const alpha = tween.values?.autoAlpha ?? tween.values?.opacity;
+    if (typeof alpha === "number" && alpha <= 0.1) state.exited = true;
+    if (typeof alpha === "number" && alpha > 0.5) state.exited = false;
+    for (const prop of ["scale", "scaleX", "scaleY"]) {
+      const value = tween.values?.[prop];
+      if (typeof value === "number" && value <= 0.05 && !tween.yoyo) state.exited = true;
+    }
+    states.set(key, state);
+  }
+  const debts = [];
+  for (const [key, state] of states) {
+    if (state.exited) continue;
+    const [scene, target] = key.split("\0");
+    const sceneEnd = endOfScene.get(scene) ?? duration3;
+    if (sceneEnd - state.lastMove < DEBT_MIN_SECONDS) continue;
+    const off = [...state.values.entries()].filter(([prop, value]) => {
+      if (prop === "x" || prop === "y") return Math.abs(value) >= 8;
+      if (prop === "xPercent" || prop === "yPercent") return Math.abs(value) >= 8;
+      if (prop === "rotation") return Math.abs(value) >= 2;
+      return Math.abs(value - 1) >= 0.03;
+    });
+    if (!off.length) continue;
+    debts.push({
+      scene,
+      target,
+      props: off.map(([prop, value]) => `${prop} ${value}`),
+      movedAt: state.lastMove,
+      sceneEnd
+    });
+  }
+  return debts.sort((a, b) => a.movedAt - b.movedAt);
+}
+function motionScoreSection(input) {
+  const { tweens, beats, duration: duration3 } = input;
+  const model = buildSceneModel(tweens, duration3);
+  const switches = model.switches.filter((swtch) => swtch.time > 0.5 || swtch.hidden.length > 0);
+  if (!switches.length) return "";
+  const lines = ["MOTION SCORE \u2014 scene changes, exits, and leftovers (whole film):"];
+  const cuts = cutAlignment(switches.map((swtch) => swtch.time), beats);
+  const secondsPerChar = duration3 > 120 ? 2 : 1;
+  const chars = Math.max(1, Math.ceil(duration3 / secondsPerChar));
+  if (beats.length) {
+    const beatRow = Array.from({ length: chars }, () => ".");
+    for (const beat of beats.flatMap((entry) => [entry.start, entry.end])) {
+      const index = Math.min(chars - 1, Math.floor(beat / secondsPerChar));
+      beatRow[index] = "|";
+    }
+    const cutRow = Array.from({ length: chars }, () => ".");
+    for (const cut of cuts) {
+      const index = Math.min(chars - 1, Math.floor(cut.time / secondsPerChar));
+      cutRow[index] = cut.aligned ? "#" : "x";
+    }
+    lines.push(`  beats  ${beatRow.join("")}`);
+    lines.push(`  cuts   ${cutRow.join("")}`);
+    lines.push(
+      `         | declared beat boundary \xB7 # scene change on a boundary \xB7 x mid-beat (${secondsPerChar}s per column)`
+    );
+  }
+  lines.push(`  SCENE CHANGES: ${switches.length} in ${duration3.toFixed(1)}s`);
+  for (const cut of cuts) {
+    if (!cut.aligned && cut.nearest !== null) {
+      lines.push(
+        `  CUT AT A RANDOM POINT: ${cut.time.toFixed(1)}s is mid-beat \u2014 the nearest declared boundary is ${cut.nearest.toFixed(1)}s. Cuts land on beat boundaries.`
+      );
+    }
+  }
+  for (const span of model.spans) {
+    const life = span.end - span.start;
+    if (life < SCENE_MIN_SECONDS) {
+      lines.push(
+        `  SCENE TOO SHORT: "${span.scene}" lived ${life.toFixed(1)}s (${span.start.toFixed(1)}\u2013${span.end.toFixed(1)}s) \u2014 shorter than a viewer can register.`
+      );
+    }
+  }
+  const exits = exitProfile(tweens, model);
+  if (exits.length) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const exit of exits) counts.set(exit.mechanism, (counts.get(exit.mechanism) ?? 0) + 1);
+    const histogram = [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([mechanism, count]) => `${mechanism} ${count}`).join(" \xB7 ");
+    lines.push(`  EXITS  [ ${exits.map((exit) => EXIT_GLYPH[exit.mechanism]).join(" ")} ]   ${histogram}`);
+    lines.push(...exitMonotonyFlags(exits).map((flag) => `  ${flag}`));
+  }
+  const debts = displacementDebt(tweens, duration3, model);
+  if (debts.length) {
+    lines.push("  DISPLACEMENT DEBT \u2014 still off their layout position when their scene ends:");
+    for (const debt of debts.slice(0, 6)) {
+      lines.push(
+        `    ${debt.target} (scene "${debt.scene}"): ${debt.props.join(", ")} from ${debt.movedAt.toFixed(1)}s until the scene ends at ${debt.sceneEnd.toFixed(1)}s (${(debt.sceneEnd - debt.movedAt).toFixed(1)}s)`
+      );
+    }
+    if (debts.length > 6) lines.push(`    \u2026and ${debts.length - 6} more`);
+  }
+  return lines.join("\n");
+}
+async function extractTimeline(page) {
+  return page.evaluate(() => {
+    const root = window.__timeline;
+    if (!root || typeof root.getChildren !== "function") return null;
+    const CONTROL = /* @__PURE__ */ new Set([
+      "duration",
+      "delay",
+      "ease",
+      "stagger",
+      "repeat",
+      "repeatDelay",
+      "yoyo",
+      "yoyoEase",
+      "paused",
+      "overwrite",
+      "immediateRender",
+      "onComplete",
+      "onStart",
+      "onUpdate",
+      "onRepeat",
+      "onReverseComplete",
+      "callbackScope",
+      "data",
+      "id",
+      "runBackwards",
+      "lazy",
+      "startAt",
+      "parent",
+      "defaults",
+      "autoRemoveChildren",
+      "smoothChildTiming",
+      "onCompleteParams",
+      "onStartParams",
+      "onUpdateParams",
+      "keyframes"
+    ]);
+    const describe3 = (target) => {
+      if (target instanceof Element) {
+        for (const attr of Array.from(target.attributes)) {
+          if (attr.name.startsWith("data-") && !attr.name.startsWith("data-studio-")) {
+            return `[${attr.name}]`;
+          }
+        }
+        if (target.id) return `${target.tagName.toLowerCase()}#${target.id}`;
+        const cls = target.classList[0];
+        return cls ? `${target.tagName.toLowerCase()}.${cls}` : target.tagName.toLowerCase();
+      }
+      if (target && typeof target === "object") {
+        return `(${target.constructor?.name ?? "object"})`;
+      }
+      return "(value)";
+    };
+    const out = [];
+    const walk = (node, offset) => {
+      for (const child of node.getChildren?.(false, true, true) ?? []) {
+        const start = offset + child.startTime();
+        if (typeof child.getChildren === "function") {
+          walk(child, start);
+          continue;
+        }
+        const vars = child.vars ?? {};
+        const props = Object.keys(vars).filter(
+          (key) => !CONTROL.has(key) && typeof vars[key] !== "function"
+        );
+        const values = {};
+        for (const key of props) {
+          const value = vars[key];
+          if (typeof value === "number" || typeof value === "string") values[key] = value;
+        }
+        const targets = child.targets?.() ?? [];
+        const firstElement = targets.find((target) => target instanceof Element);
+        const scene = firstElement?.closest("[data-scene]")?.getAttribute("data-scene") ?? null;
+        const easeRaw = vars.ease;
+        out.push({
+          start,
+          end: start + child.totalDuration(),
+          targets: [...new Set(targets.map(describe3))],
+          props,
+          ease: typeof easeRaw === "string" ? easeRaw : easeRaw ? "custom" : "default",
+          values,
+          scene,
+          yoyo: Boolean(vars.yoyo)
+        });
+      }
+    };
+    walk(root, 0);
+    return out;
+  });
+}
+async function compositeAndDiff(page, frames, options = {}) {
+  return page.evaluate(
+    async (input) => {
+      const imgs = [];
+      for (const [index, frame] of input.frames.entries()) {
+        const img = new Image();
+        await new Promise((resolve, reject) => {
+          img.onload = () => resolve();
+          img.onerror = () => reject(new Error(`frame ${index} failed to load`));
+          img.src = "data:image/jpeg;base64," + frame.base64;
+        });
+        imgs.push(img);
+      }
+      const dw = 160;
+      const dh = 90;
+      const diffCanvas = document.createElement("canvas");
+      diffCanvas.width = dw;
+      diffCanvas.height = dh;
+      const diffCtx = diffCanvas.getContext("2d", { willReadFrequently: true });
+      if (!diffCtx) throw new Error("2d canvas unavailable");
+      let prev = null;
+      const diffs = [];
+      const cellDiffs = [];
+      const gridCols = 8;
+      const gridRows = 6;
+      const cellW = dw / gridCols;
+      const cellH = dh / gridRows;
+      for (const img of imgs) {
+        diffCtx.drawImage(img, 0, 0, dw, dh);
+        const data = diffCtx.getImageData(0, 0, dw, dh).data;
+        if (prev) {
+          let changed = 0;
+          const cells = new Array(gridCols * gridRows).fill(0);
+          for (let i = 0; i < data.length; i += 4) {
+            const delta = Math.abs(data[i] - prev[i]) + Math.abs(data[i + 1] - prev[i + 1]) + Math.abs(data[i + 2] - prev[i + 2]);
+            if (delta > 60) {
+              changed += 1;
+              const px = i / 4 % dw;
+              const py = Math.floor(i / 4 / dw);
+              cells[Math.floor(py / cellH) * gridCols + Math.floor(px / cellW)] += 1;
+            }
+          }
+          diffs.push(changed / (dw * dh));
+          cellDiffs.push(cells.map((count) => count / (cellW * cellH)));
+        }
+        prev = data.slice();
+      }
+      if (!input.includeSheets) return { sheets: [], diffs, cellDiffs };
+      const ratio = imgs[0].naturalHeight / Math.max(1, imgs[0].naturalWidth);
+      const tw = input.tileWidth;
+      const th = Math.round(tw * ratio);
+      const sheets = [];
+      for (let s = 0; s * input.perSheet < imgs.length; s += 1) {
+        const slice = imgs.slice(s * input.perSheet, (s + 1) * input.perSheet);
+        const rows = Math.ceil(slice.length / input.columns);
+        const canvas = document.createElement("canvas");
+        canvas.width = input.columns * tw;
+        canvas.height = rows * th;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) throw new Error("2d canvas unavailable");
+        ctx.fillStyle = "#000";
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
+        slice.forEach((img, i) => {
+          const x = i % input.columns * tw;
+          const y = Math.floor(i / input.columns) * th;
+          ctx.drawImage(img, x, y, tw, th);
+          const label = input.frames[s * input.perSheet + i].time.toFixed(2) + "s";
+          ctx.font = "bold 16px monospace";
+          const width = ctx.measureText(label).width + 10;
+          ctx.fillStyle = "rgba(0,0,0,0.72)";
+          ctx.fillRect(x, y, width, 22);
+          ctx.fillStyle = "#ffd21f";
+          ctx.fillText(label, x + 5, y + 16);
+        });
+        sheets.push(canvas.toDataURL("image/jpeg", 0.8).split(",")[1]);
+      }
+      return { sheets, diffs, cellDiffs };
+    },
+    {
+      frames,
+      columns: options.columns ?? 4,
+      tileWidth: options.tileWidth ?? 480,
+      perSheet: options.perSheet ?? 16,
+      includeSheets: options.includeSheets ?? true
+    }
+  );
+}
+var getMotionTool = {
+  name: "get_motion",
+  title: "See and measure motion over an interval",
+  description: "MOTION LAB (local experiment). Sample the draft densely across a time window and return (1) timestamp-labelled contact sheets \u2014 adjacent tiles are one sample apart, so the difference between tiles IS the motion \u2014 and (2) a measured report: % of pixels changing per interval, dead-air spans where nothing perceptible moves, and every tween the built timeline actually schedules in the window, flagging tweens that run without producing visible change. Static frames cannot show velocity, overlap, or dead air; this can. Call it over the full duration after every preview build, then narrow in on weak windows. Use get_frames for composition close-ups only.",
+  inputSchema: {
+    draftId: external_exports.string().describe("The draft id."),
+    from: external_exports.number().min(0).optional().describe("Window start in seconds. Defaults to 0."),
+    to: external_exports.number().min(0).optional().describe("Window end in seconds. Defaults to the scene duration."),
+    everyNthFrame: external_exports.number().int().min(1).max(30).optional().describe(
+      `Sample one frame in N. Default ${DEFAULT_EVERY_NTH_FRAME} (6 samples/second at 30fps) \u2014 the density at which motion becomes readable across stills.`
+    ),
+    detail: external_exports.enum(["quick", "full"]).optional().describe(
+      'quick (default): numbers only \u2014 dead air, focal budget, text census \u2014 sparser sampling, NO contact-sheet images, no metric catalog. Cheap enough to run after every revision. full: dense sampling with contact sheets and the catalog, when you need to SEE motion mid-flight. Measure at most twice per revision; finish with reviewMode "final".'
+    ),
+    reviewMode: external_exports.enum(["final"]).optional().describe(
+      'Quality-loop lens: "final" forces a full-duration pass at one-frame-in-five density and records export-eligible motion-coverage evidence for the current revision.'
+    )
+  },
+  local: true,
+  // Metered as a frame capture: the deployed admission policy budgets
+  // get_frames for exactly the routes this tool invokes (get-draft,
+  // list-projects), and one motion pass is one capture.
+  admitAs: "get_frames",
+  handler: async (args, ctx, progress) => {
+    const finalReview = args.reviewMode === "final";
+    const session = await openPreview(ctx, String(args.draftId));
+    try {
+      const duration3 = session.duration;
+      const from = finalReview ? 0 : Math.max(0, Math.min(Number(args.from ?? 0), duration3));
+      const to = finalReview ? duration3 : Math.max(0, Math.min(Number(args.to ?? duration3), duration3));
+      if (to <= from) {
+        return {
+          text: `get_motion needs from < to within 0\u2013${formatTime(duration3)}s (got ${from}\u2013${to}).`,
+          isError: true
+        };
+      }
+      const passPlan = motionPassPlan({
+        finalReview,
+        detail: args.detail ? String(args.detail) : void 0,
+        everyNthFrame: args.everyNthFrame === void 0 ? void 0 : Number(args.everyNthFrame)
+      });
+      const everyNthFrame = passPlan.everyNthFrame;
+      const plan = sampleTimes({
+        from,
+        to,
+        fps: session.fps,
+        everyNthFrame,
+        maxSamples: passPlan.maxSamples
+      });
+      const frames = [];
+      const textSamples = [];
+      const censusOn = textCensusEnabled();
+      for (const [index, time3] of plan.times.entries()) {
+        if (progress?.signal?.aborted) break;
+        await renderSettledFrame(session.page, time3);
+        const shot = await session.page.screenshot({ type: "jpeg", quality: 80 });
+        frames.push({ time: time3, base64: shot.toString("base64") });
+        if (censusOn) {
+          try {
+            textSamples.push({ time: time3, blocks: await sampleTextBlocks(session.page, CANDIDATE_MIN_PX) });
+          } catch {
+          }
+        }
+        progress?.report?.({
+          progress: index + 1,
+          total: plan.times.length,
+          message: `sampled t=${formatTime(time3)}s`
+        });
+      }
+      const tweensAll = await extractTimeline(session.page);
+      const tweens = tweensAll ? tweensAll.filter((tween) => tween.end > from && tween.start < to) : null;
+      const sheetPage = await session.browser.newPage();
+      const { sheets, diffs, cellDiffs } = await compositeAndDiff(sheetPage, frames, {
+        includeSheets: passPlan.includeSheets
+      });
+      let catalogSection = "";
+      if (passPlan.includeCatalog && metricCatalogEnabled() && frames.length >= 2) {
+        try {
+          const features = await sampleCatalogFeatures(sheetPage, frames);
+          const records = computeCatalogMetrics({
+            features,
+            dtSeconds: plan.stepSeconds,
+            durationSeconds: to - from
+          });
+          catalogSection = formatCatalogReport(records);
+        } catch (error51) {
+          catalogSection = "CANONICAL METRICS unavailable this pass: " + (error51 instanceof Error ? error51.message : String(error51));
+        }
+      }
+      const intervals = buildIntervals(
+        frames.map((frame) => frame.time),
+        diffs
+      );
+      const censusSection = censusOn && textSamples.length ? textCensusReport(textSamples) : "";
+      let contractSection = "";
+      if (textContractEnabled() && textSamples.length >= 2) {
+        try {
+          const dims = await session.page.evaluate(() => ({
+            width: window.innerWidth,
+            height: window.innerHeight
+          }));
+          contractSection = formatTextContractReport(
+            analyzeTextContract({
+              samples: textSamples,
+              diffs,
+              frameWidth: dims.width,
+              frameHeight: dims.height,
+              stepSeconds: plan.stepSeconds,
+              lockedContent: ctx.qualityLoopState?.lockedContentByDraft.get(String(args.draftId)),
+              inspectV2: inspectV2Enabled()
+            })
+          );
+        } catch {
+        }
+      }
+      let v2Section = "";
+      if (inspectV2Enabled()) {
+        const v2Lines = [];
+        const envelope = envelopeLine(intervals);
+        if (envelope) v2Lines.push(envelope);
+        const beats = ctx.qualityLoopState?.beatsByDraft.get(String(args.draftId)) ?? [];
+        v2Lines.push(...beatVerdicts(beats, intervals));
+        v2Lines.push(
+          ...repairMenu({
+            deadSpans: deadAirSpans(intervals),
+            imperceptible: tweens ? imperceptibleTweens(tweens, intervals) : [],
+            textSamples
+          })
+        );
+        v2Section = v2Lines.join("\n");
+      }
+      let scoreSection = "";
+      if (motionScoreEnabled() && tweensAll?.length) {
+        try {
+          scoreSection = motionScoreSection({
+            tweens: tweensAll,
+            beats: ctx.qualityLoopState?.beatsByDraft.get(String(args.draftId)) ?? [],
+            duration: duration3
+          });
+        } catch {
+        }
+      }
+      const splitFocus = splitFocusMoments(
+        frames.map((frame) => frame.time),
+        cellDiffs
+      );
+      const breathless = breathlessSpans(intervals);
+      const cadence = tweens ? cadenceMoments(tweens) : void 0;
+      const report = motionReport({ from, to, plan, everyNthFrame, intervals, tweens, duration: duration3, splitFocus, breathless, cadence });
+      const lines = [
+        report,
+        ...passPlan.includeSheets ? [] : [
+          "",
+          'QUICK PASS \u2014 numbers only, no frames attached. Run detail: "full" when you need to SEE the motion, and reviewMode: "final" for the export-evidence review.'
+        ],
+        ...censusSection ? ["", censusSection] : [],
+        ...contractSection ? ["", contractSection] : [],
+        ...scoreSection ? ["", scoreSection] : [],
+        ...v2Section ? ["", v2Section] : [],
+        ...catalogSection ? ["", catalogSection] : [],
+        ...session.warnings.map((warning) => `WARNING: ${warning}`),
+        "",
+        "These are measurements, not style rules. Dead air and imperceptible tweens are time no one is directing \u2014 decide narratively what should own that time, change the direction, and measure again."
+      ];
+      if (ctx.qualityLoop) {
+        if (!finalReview) {
+          lines.push(
+            'QUALITY LOOP: this pass is not export evidence. Record motion coverage with get_motion({ draftId, reviewMode: "final" }) once the cut is complete.'
+          );
+        } else {
+          const stalePreview = session.warnings.some(
+            (warning) => warning.startsWith("The preview bundle is at revision ")
+          );
+          if (stalePreview) {
+            lines.push(
+              "MOTION REVIEW NOT RECORDED: these samples came from a stale preview bundle. Wait for the current revision to build, then review it again."
+            );
+          } else {
+            ctx.qualityLoopState?.finalMotionReviewByDraft.set(String(args.draftId), {
+              revision: session.revision,
+              duration: duration3,
+              stepSeconds: plan.stepSeconds,
+              samples: plan.times.length
+            });
+            lines.push(
+              `FINAL MOTION REVIEW RECORDED for revision ${session.revision} \u2014 ${plan.times.length} samples, ${plan.stepSeconds.toFixed(3)}s apart` + (plan.coarsened ? " (coarsened below one-in-five by film length)" : "") + ". Any later edit invalidates this evidence."
+            );
+            lines.push(qualityReviewPrompt("final"));
+          }
+        }
+      }
+      return {
+        text: lines.join("\n"),
+        images: sheets.map((base643) => ({ base64: base643, mimeType: "image/jpeg" }))
+      };
+    } finally {
+      await session.browser.close().catch(() => void 0);
+    }
+  }
+};
+function motionLabServerInstructions() {
+  return `
+
+MOTION LAB IS ENABLED \u2014 an opt-in local experiment:
+Static frames measure composition; they are blind to velocity, overlap, and dead air. After every successful preview build, call get_motion across the full duration BEFORE judging the cut, and again on any window you edit. Treat its output as measurements, not style rules: a dead-air span or a flagged imperceptible tween is time no one is directing \u2014 decide what should own that time, fix the direction, and measure again. A cut is not done while the report shows dead air you did not choose deliberately. get_frames remains the tool for composition close-ups.
+When the quality loop is also enabled, the final review is two-part and export requires both on the same revision: get_frames({ reviewMode: "final" }) for composition and legibility at native resolution, and get_motion({ draftId, reviewMode: "final" }) for full-duration motion coverage at one frame in five.`;
+}
+
+// src/mcp/gather-references.ts
+import { existsSync, statSync } from "node:fs";
+var referenceEntry = external_exports.object({
+  kind: external_exports.enum(["local-code", "product-ui-screenshot", "site-code", "website", "screenshot", "image-to-use", "component-class-image", "mockup"]),
+  /** URL or local file path. */
+  source: external_exports.string().trim().min(4),
+  /** What this reference will inform, e.g. "the terminal styling". */
+  informs: external_exports.string().trim().min(5)
+});
+var gatherReferencesInput = {
+  references: external_exports.array(referenceEntry).optional().describe(
+    "The references found. URLs are fetched to verify they exist; local paths are checked on disk."
+  ),
+  noneFound: external_exports.object({ searched: external_exports.array(external_exports.string().trim().min(3)).min(2) }).optional().describe(
+    'Only when the fallback ladder is exhausted: what was searched (local code, product site, component-class images). The film proceeds marked "designed from convention".'
+  )
+};
+async function captureSource(source) {
+  if (/^https?:\/\//i.test(source)) {
+    let browser = null;
+    try {
+      browser = await launchChromium();
+      const page = await browser.newPage({ viewport: { width: 1440, height: 900 } });
+      await page.goto(source, { waitUntil: "load", timeout: 2e4 });
+      await page.waitForTimeout(1200);
+      const shot = await page.screenshot({ type: "jpeg", quality: 75 });
+      return { verified: true, image: { base64: shot.toString("base64"), mimeType: "image/jpeg" } };
+    } catch {
+      return { verified: false };
+    } finally {
+      await browser?.close().catch(() => void 0);
+    }
+  }
+  try {
+    return { verified: existsSync(source) && statSync(source).size > 0 };
+  } catch {
+    return { verified: false };
+  }
+}
+var gatherReferencesTool = {
+  name: "gather_references",
+  title: "Record and verify the film's design references",
+  description: `PHASED FLOW step 1b \u2014 REQUIRED before create_video when the phased flow is enabled. FIRST STUDY, THEN RECORD: if your environment has web/image search and an image-viewing tool (e.g. view_image), use them BEFORE calling this \u2014 search for real screenshots of the product in use and real examples of each component class you will build, download and VIEW them so their pixels are in your context. Then record here what you studied. The references that matter are of the ACTUAL SOFTWARE \u2014 what the product looks like in use (its app, editor, dashboard, the real screens users see) \u2014 NOT the marketing homepage. Fallback ladder: the product's real front-end code on this machine (best \u2014 also pass it as appCode) \u2192 product-ui-screenshots from its own docs, help center, changelog, demo videos, or review sites \u2192 the product's site code \u2192 the marketing site (weakest; styling tokens only) \u2192 images of the component CLASS (a real terminal, a real dashboard) \u2192 mockups. Each URL is fetched to verify it is RENDERED and its screenshot returned to you \u2014 study those pixels. Style components to match what the references actually show. Only when the ladder is genuinely exhausted, call with noneFound listing what you searched \u2014 the film then proceeds marked "designed from convention". Rights note: searched images are styling references ONLY; image-to-use entries (placed in the film) must come from the product's own assets or press kit, never search thumbnails.`,
+  inputSchema: gatherReferencesInput,
+  local: true,
+  // No cloud routes are invoked; alias to an unmetered name so admission is skipped.
+  admitAs: "studio_link",
+  handler: async (args, ctx) => {
+    const references = args.references ?? [];
+    const noneFound = args.noneFound;
+    if (!references.length && !noneFound) {
+      return {
+        text: "Pass references (each with kind, source, informs) or \u2014 only after genuinely exhausting the fallback ladder \u2014 noneFound with what you searched.",
+        isError: true
+      };
+    }
+    const entries = [];
+    const images = [];
+    for (const reference of references.slice(0, 6)) {
+      const captured = await captureSource(reference.source);
+      entries.push({ ...reference, verified: captured.verified });
+      if (captured.image) images.push(captured.image);
+    }
+    const ledger = { entries, ...noneFound ? { noneFound } : {} };
+    if (ctx.qualityLoopState) ctx.qualityLoopState.referenceLedger = ledger;
+    process.stderr.write("gather_references ledger: " + JSON.stringify(ledger) + "\n");
+    const verified = entries.filter((entry) => entry.verified).length;
+    const lines = [
+      `Reference ledger recorded: ${entries.length} reference(s), ${verified} verified.`,
+      ...entries.map(
+        (entry) => `  [${entry.verified ? "ok" : "UNVERIFIED"}] ${entry.kind}: ${entry.source} \u2192 informs ${entry.informs}`
+      ),
+      ...noneFound ? [`  none-found declared; searched: ${noneFound.searched.join("; ")}`] : [],
+      ...entries.length && !verified && !noneFound ? ["WARNING: nothing verified \u2014 fix the sources or declare noneFound honestly."] : [],
+      images.length ? "The screenshots above ARE your references \u2014 design the components to match what they actually show, not what you imagine the product looks like." : "Design to what the references actually show. The final review judges fidelity against this ledger."
+    ];
+    return { text: lines.join("\n"), images };
+  }
+};
+
+// src/mcp/install-kits.ts
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+var KIT_FILES = [
+  "kits",
+  "reveal",
+  "actions",
+  "ensemble",
+  "looks",
+  "sentence",
+  "morphkit",
+  "highlight",
+  "impact",
+  "streamkit"
+];
+function readKitSources() {
+  return KIT_FILES.map((name) => ({
+    path: `kit/${name}.ts`,
+    content: readFileSync(
+      fileURLToPath(new URL(`../assets/kits/${name}.ts`, import.meta.url)),
+      "utf8"
+    )
+  }));
+}
+var installKitsTool = {
+  name: "install_kits",
+  title: "Install the interaction and showpiece kits into a draft",
+  description: "Write the house kits into the draft under kit/ so direction.ts can import them instead of hand-rolling primitives. Call this ONCE right after create_video, before writing your own files. Provides: kit/actions (a STATEFUL cursor actor \u2014 travels from where it is, decelerates into targets, presses with squash, types with a real caret; plus scroll and ui.set state changes), kit/ensemble (fountain, confetti, assemble, scatter, dropIn showpieces with closed-form ballistics), kit/looks (hero angle-zoom, tilt, dropIn entrances), kit/sentence (append/swap/stress/morphWord/chip typography), kit/morphkit, kit/highlight, kit/impact, kit/streamkit. Import as e.g. `import { createCursorKit } from './kit/actions'`. NEVER hand-roll a cursor, click, confetti burst, or fountain when the kit already does it \u2014 hand-rolled cursors teleport and click before they arrive.",
+  inputSchema: {
+    draftId: external_exports.string().describe("The draft to install the kits into.")
+  },
+  local: true,
+  // This is a draft write in route terms; meter it as one.
+  admitAs: "write_draft_files",
+  handler: async (args, ctx) => {
+    const sources = readKitSources();
+    const files = Object.fromEntries(sources.map((file2) => [file2.path, file2.content]));
+    const output = await saveDraft(ctx, String(args.draftId), () => ({
+      files,
+      deletedPaths: []
+    }));
+    if (output.isError) return output;
+    return {
+      text: `Installed ${sources.length} kit files under kit/. Import from './kit/actions', './kit/ensemble', './kit/looks', './kit/sentence' etc. in direction.ts. NEVER hand-roll what they provide.
+` + output.text
+    };
+  }
+};
+
+// src/mcp/install-font.ts
+var FONTSOURCE_CDN = "https://cdn.jsdelivr.net/npm/@fontsource";
+var MAX_WOFF2_BYTES = 3e5;
+var MAX_TOTAL_BYTES = 9e5;
+function fontsourceSlug(family) {
+  return family.trim().toLowerCase().replace(/['’]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function fontsourceUrl(family, weight, italic = false) {
+  const slug = fontsourceSlug(family);
+  return `${FONTSOURCE_CDN}/${slug}/files/${slug}-latin-${weight}-${italic ? "italic" : "normal"}.woff2`;
+}
+var MARKER = (family, weight, italic) => `/* install_font: ${family} ${weight}${italic ? " italic" : ""} */`;
+function fontFaceCss(family, entries) {
+  return entries.map(
+    (entry) => `${MARKER(family, entry.weight, entry.italic)}
+@font-face {
+  font-family: '${family}';
+  font-style: ${entry.italic ? "italic" : "normal"};
+  font-weight: ${entry.weight};
+  font-display: block;
+  src: url(data:font/woff2;base64,${entry.base64}) format('woff2');
+}`
+  ).join("\n");
+}
+function mergeFontCss(existing, family, entries) {
+  const fresh = entries.filter((entry) => !existing.includes(MARKER(family, entry.weight, entry.italic)));
+  if (!fresh.length) return { css: existing, added: 0, skipped: entries.length };
+  const block = fontFaceCss(family, fresh);
+  const css = existing ? `${existing.replace(/\s*$/, "")}
+
+${block}
+` : `${block}
+`;
+  return { css, added: fresh.length, skipped: entries.length - fresh.length };
+}
+function notFoundMessage(family) {
+  return `"${family}" is not on Fontsource, which carries open-licensed fonts only \u2014 this usually means it is a commercial face that cannot legally be auto-installed. Either use the closest bundled or open alternative and note the substitution, or ask the user to supply licensed font files. Do NOT fake it with an unbundled system family: the render guard will refuse, and rightly.`;
+}
+var installFontTool = {
+  name: "install_font",
+  title: "Package an open-licensed font into a draft",
+  description: "Download an open-licensed font family (Fontsource: Google Fonts and friends) and inline it into the draft's styles.css as @font-face data URIs, so the render font guard passes and previews, exports, and every machine render the same glyphs. Use when the brand calls for a font outside the bundled set. Commercial faces are refused with an explanation \u2014 substitute openly and say so, never fake with a system family. Returns the exact font-family value to use. If styles.css was created fresh, import it from App.tsx.",
+  inputSchema: {
+    draftId: external_exports.string().describe("The draft to install the font into."),
+    family: external_exports.string().min(2).describe('Font family name, e.g. "Space Grotesk".'),
+    weights: external_exports.array(external_exports.number().int().min(100).max(900)).min(1).max(6).optional().describe("Weights to install (default [400, 700])."),
+    italic: external_exports.boolean().optional().describe("Also install italic styles (default false).")
+  },
+  local: true,
+  // Route-wise this is a draft write; meter it as one.
+  admitAs: "write_draft_files",
   handler: async (args, ctx) => {
-    const result = await ctx.invoke("motion-library", {
+    const family = String(args.family).trim();
+    const weights = [...new Set(args.weights ?? [400, 700])].sort(
+      (a, b) => a - b
+    );
+    const styles = args.italic ? [false, true] : [false];
+    const entries = [];
+    let total = 0;
+    for (const italic of styles) {
+      for (const weight of weights) {
+        const url2 = fontsourceUrl(family, weight, italic);
+        let response;
+        try {
+          response = await fetch(url2);
+        } catch (error51) {
+          return {
+            isError: true,
+            text: `Could not reach the font CDN (${error51 instanceof Error ? error51.message : String(error51)}). Check network and retry.`
+          };
+        }
+        if (response.status === 404) {
+          if (!entries.length && weight === weights[0] && !italic) {
+            return { isError: true, text: notFoundMessage(family) };
+          }
+          return {
+            isError: true,
+            text: `"${family}" exists but has no ${italic ? "italic " : ""}${weight} file on Fontsource. Retry with the weights it actually ships (most families carry 400/500/600/700).`
+          };
+        }
+        if (!response.ok) {
+          return { isError: true, text: `Font CDN returned ${response.status} for ${url2}.` };
+        }
+        const bytes = Buffer.from(await response.arrayBuffer());
+        if (bytes.length > MAX_WOFF2_BYTES) {
+          return {
+            isError: true,
+            text: `${family} ${weight} is ${Math.round(bytes.length / 1024)}KB \u2014 over the ${Math.round(MAX_WOFF2_BYTES / 1024)}KB per-file ceiling.`
+          };
+        }
+        total += bytes.length;
+        if (total > MAX_TOTAL_BYTES) {
+          return {
+            isError: true,
+            text: `Requested weights total over ${Math.round(MAX_TOTAL_BYTES / 1024)}KB \u2014 install fewer weights.`
+          };
+        }
+        entries.push({ weight, italic, base64: bytes.toString("base64") });
+      }
+    }
+    let created = false;
+    let mergeResult = { added: 0, skipped: 0 };
+    const output = await saveDraft(ctx, String(args.draftId), (draft) => {
+      const existing = draft.files["styles.css"] ?? "";
+      created = !("styles.css" in draft.files);
+      const merged = mergeFontCss(existing, family, entries);
+      mergeResult = { added: merged.added, skipped: merged.skipped };
+      const files = merged.added ? { "styles.css": merged.css } : {};
+      return { files, deletedPaths: [] };
+    });
+    if (output.isError) return output;
+    const kb = Math.round(total / 1024);
+    return {
+      text: `Installed "${family}" (${mergeResult.added} face${mergeResult.added === 1 ? "" : "s"}` + (mergeResult.skipped ? `, ${mergeResult.skipped} already present` : "") + `, ~${kb}KB inlined) into styles.css. Use font-family: '${family}'. ` + (created ? "styles.css was CREATED \u2014 add `import './styles.css'` to App.tsx or the fonts never load. " : "") + output.text
+    };
+  }
+};
+
+// src/mcp/open-studio.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var CHROMIUM_BROWSERS = ["Google Chrome", "Arc", "Brave Browser", "Microsoft Edge"];
+async function osascript(script) {
+  const { stdout } = await run("osascript", ["-e", script], { timeout: 4e3 });
+  return stdout.trim();
+}
+async function appRunning(app) {
+  try {
+    return await osascript(`tell application "System Events" to (name of processes) contains "${app}"`) === "true";
+  } catch {
+    return false;
+  }
+}
+async function focusChromiumTab(app, needle) {
+  const script = `
+    tell application "${app}"
+      set wIndex to 0
+      repeat with w in windows
+        set wIndex to wIndex + 1
+        set tIndex to 0
+        repeat with t in tabs of w
+          set tIndex to tIndex + 1
+          if (URL of t as text) contains "${needle}" then
+            set active tab index of window wIndex to tIndex
+            set index of window wIndex to 1
+            activate
+            return URL of t as text
+          end if
+        end repeat
+      end repeat
+    end tell
+    return ""`;
+  try {
+    const url2 = await osascript(script);
+    return url2 || null;
+  } catch {
+    return null;
+  }
+}
+async function focusSafariTab(needle) {
+  const script = `
+    tell application "Safari"
+      repeat with w in windows
+        repeat with t in tabs of w
+          if (URL of t as text) contains "${needle}" then
+            tell w to set current tab to t
+            set index of w to 1
+            activate
+            return URL of t as text
+          end if
+        end repeat
+      end repeat
+    end tell
+    return ""`;
+  try {
+    const url2 = await osascript(script);
+    return url2 || null;
+  } catch {
+    return null;
+  }
+}
+async function findOpenStudioTab(needle) {
+  if (process.platform !== "darwin") return null;
+  for (const app of CHROMIUM_BROWSERS) {
+    if (!await appRunning(app)) continue;
+    const url2 = await focusChromiumTab(app, needle);
+    if (url2) return { browser: app, url: url2 };
+  }
+  if (await appRunning("Safari")) {
+    const url2 = await focusSafariTab(needle);
+    if (url2) return { browser: "Safari", url: url2 };
+  }
+  return null;
+}
+async function openInBrowser(url2) {
+  if (process.platform === "darwin") await run("open", [url2]);
+  else if (process.platform === "win32") await run("cmd", ["/c", "start", "", url2]);
+  else await run("xdg-open", [url2]);
+}
+var openStudioTool = {
+  name: "open_studio",
+  title: "Open the studio in the browser",
+  description: "Open the web studio at a project (optionally a specific draft) in the user's browser. Checks first whether a studio tab for that project is already open and focuses it instead of opening a duplicate. Use when the user asks to see or pull up a project.",
+  inputSchema: {
+    projectId: external_exports.string().describe("The project id."),
+    slug: external_exports.string().optional().describe("Draft slug to open directly.")
+  },
+  handler: async (args, ctx) => {
+    const url2 = studioLink(ctx, String(args.projectId), args.slug);
+    const needle = `/projects/${String(args.projectId)}`;
+    try {
+      const existing = await findOpenStudioTab(needle);
+      if (existing) {
+        return {
+          text: `Already open \u2014 focused the existing studio tab in ${existing.browser} (${existing.url}).` + (args.slug && !existing.url.includes(`scene=${args.slug}`) ? ` It is on a different draft; the user can switch cuts there, or open ${url2} for ${args.slug} directly.` : "")
+        };
+      }
+      await openInBrowser(url2);
+      return { text: `Opened the studio in the user's browser: ${url2}` };
+    } catch (cause) {
+      return {
+        text: `Could not open a browser here (${cause instanceof Error ? cause.message : String(cause)}). Give the user the link instead: ${url2}`
+      };
+    }
+  }
+};
+
+// src/mcp/connect.ts
+var CONNECT_WAIT_SECONDS = 300;
+async function connectWorkspace(input, deps) {
+  const grant = await deps.request(deps.supabaseUrl, "cli-device-auth", {
+    action: "start"
+  });
+  const browserOpened = deps.open(grant.verificationUri);
+  const expiry = Date.parse(grant.expiresAt);
+  const deadline = Math.min(
+    deps.now() + input.waitMs,
+    Number.isNaN(expiry) ? Infinity : expiry
+  );
+  const intervalMs = Math.max(1, grant.intervalSeconds || 2) * 1e3;
+  while (deps.now() < deadline) {
+    let poll;
+    try {
+      poll = await deps.request(deps.supabaseUrl, "cli-device-auth", {
+        action: "poll",
+        deviceCode: grant.deviceCode
+      });
+    } catch (error51) {
+      if (error51 instanceof ApiError && error51.status === 410) break;
+      throw error51;
+    }
+    if (poll.status === "authorized") {
+      deps.persist({
+        apiKey: poll.apiKey,
+        supabaseUrl: deps.supabaseUrl,
+        appUrl: deps.appUrl
+      });
+      return { status: "connected", userCode: grant.userCode, browserOpened };
+    }
+    await deps.sleep(intervalMs);
+  }
+  return {
+    status: "timeout",
+    userCode: grant.userCode,
+    verificationUri: grant.verificationUri,
+    browserOpened
+  };
+}
+var connectTool = {
+  name: "connect",
+  title: "Connect this workspace",
+  description: "Authenticate Impractical Motion for this machine. Opens the user's browser to approve the connection, waits for them to confirm, and stores the credential locally. TELL THE USER YOU ARE ABOUT TO OPEN THEIR BROWSER BEFORE CALLING THIS \u2014 the call blocks until they approve. Use it whenever a tool reports that the workspace is not connected.",
+  inputSchema: {
+    waitSeconds: external_exports.number().optional().describe(`How long to wait for browser approval. Default ${CONNECT_WAIT_SECONDS}.`)
+  },
+  local: true,
+  handler: async (args, ctx) => {
+    const stored = loadConfig();
+    const supabaseUrl = stored.supabaseUrl ?? PRODUCTION_SUPABASE_URL;
+    const appUrl = stored.appUrl ?? PRODUCTION_APP_URL;
+    const result = await connectWorkspace(
+      // Capped like every other wait: a browser approval that outlives the MCP
+      // client's request deadline reports a failure the user then repeats,
+      // burning a second device grant on an approval that already worked.
+      { waitMs: waitBudgetMs(args.waitSeconds, CONNECT_WAIT_SECONDS) },
+      {
+        request: (url2, name, body) => invokeAt(url2, name, body),
+        open: openBrowser,
+        persist: saveConfig,
+        sleep: (ms) => ctx.sleep ? ctx.sleep(ms) : new Promise((r) => setTimeout(r, ms)),
+        now: () => Date.now(),
+        supabaseUrl,
+        appUrl
+      }
+    );
+    if (result.status === "timeout") {
+      return {
+        text: `Nobody approved the connection in time. Ask the user to open ${result.verificationUri} and confirm code ${result.userCode}, then call connect again.`,
+        isError: true
+      };
+    }
+    try {
+      const snapshot = await ctx.invoke(
+        "workspace-bootstrap"
+      );
+      return {
+        text: `Connected to workspace ${snapshot.orgId}` + (snapshot.hasAccess ? "." : " \u2014 but it has no active access; check billing in the web app.")
+      };
+    } catch (error51) {
+      const message = error51 instanceof Error ? error51.message : String(error51);
+      return {
+        text: `Credential saved, but the workspace check failed: ${message}`,
+        isError: true
+      };
+    }
+  }
+};
+var isNotConnected = (message) => /Not connected|Not configured/i.test(message);
+
+// src/mcp/motion-context.ts
+import { readFile } from "node:fs/promises";
+var LOCAL_MOTION_LIBRARY_ENV = "IMPRACTICAL_MOTION_LIBRARY_FILE";
+function parseLocalMotionLibrary(source, filePath = "local motion library") {
+  const prefix = "export const MOTION_LIBRARY_DATA = ";
+  const start = source.indexOf(prefix);
+  const end = source.lastIndexOf(" as const");
+  if (start < 0 || end < 0 || end <= start + prefix.length) {
+    throw new Error(`${filePath} is not a generated motion-library data module`);
+  }
+  let value;
+  try {
+    value = JSON.parse(source.slice(start + prefix.length, end).trim());
+  } catch (error51) {
+    throw new Error(
+      `Could not parse ${filePath}: ${error51 instanceof Error ? error51.message : String(error51)}`
+    );
+  }
+  const data = value;
+  if (typeof data.version !== "string" || typeof data.engineVersion !== "string" || !Array.isArray(data.styles) || !Array.isArray(data.templates)) {
+    throw new Error(`${filePath} is missing required generated motion-library fields`);
+  }
+  return data;
+}
+var replaceSelectedItems = (selected, local) => {
+  if (!selected?.length) return [];
+  const byId = new Map(local.map((item) => [item.id, item]));
+  return selected.map((item) => byId.get(item.id) ?? item);
+};
+function overlayLocalMotionLibrary(remote, local, filePath, detail) {
+  const productionLibraryVersion = remote.libraryVersion;
+  return {
+    ...remote,
+    schemaVersion: local.schemaVersion,
+    libraryVersion: local.version,
+    engineVersion: local.engineVersion,
+    catalog: local.catalog,
+    guidance: local.guidance,
+    styles: replaceSelectedItems(remote.styles, local.styles),
+    templates: replaceSelectedItems(remote.templates, local.templates),
+    sharedReferences: detail === "full" ? local.sharedReferences : void 0,
+    localLibraryOverride: {
+      enabled: true,
+      source: filePath,
+      productionLibraryVersion
+    },
+    note: `LOCAL TEST OVERRIDE: guidance and selected references come from ${filePath}. Production currently returned library ${productionLibraryVersion}. No production deployment was used.`
+  };
+}
+async function applyLocalMotionLibraryOverride(remote, detail) {
+  const filePath = process.env[LOCAL_MOTION_LIBRARY_ENV]?.trim();
+  if (!filePath) return remote;
+  const source = await readFile(filePath, "utf8");
+  return overlayLocalMotionLibrary(remote, parseLocalMotionLibrary(source, filePath), filePath, detail);
+}
+var motionContextTool = {
+  name: "motion_context",
+  title: "Study the motion library",
+  description: `Retrieve the current versioned house skills, relevant templates, selected production reference sources, and rendered style frames for this brief. CALL THIS after engine_types and before create_video. The production library is fetched live; local development may explicitly override its guidance with ${LOCAL_MOTION_LIBRARY_ENV}.`,
+  inputSchema: {
+    brief: external_exports.string().min(1).describe("What the video should communicate and how it should feel."),
+    styleId: external_exports.string().optional().describe("Optional style id from a previous motion_context result."),
+    templateId: external_exports.string().optional().describe("Optional template id to study in detail."),
+    brandSlug: external_exports.string().optional().describe("Brand kit slug when this video is for a known brand. Personalizes the result."),
+    contentType: external_exports.string().optional().describe("Kind of video, e.g. 'launch-promo', 'logo-sting', 'product-demo'."),
+    detail: external_exports.enum(["focused", "full"]).optional().describe("Focused returns selected references. Full also exposes all shared source references."),
+    includeReferenceFrames: external_exports.boolean().optional().describe("Render four frames from the best matching production reference. Default true.")
+  },
+  local: true,
+  handler: async (args, ctx) => {
+    const detail = args.detail === "full" ? "full" : "focused";
+    const remoteResult = await ctx.invoke("motion-library", {
       brief: args.brief,
       styleId: args.styleId,
       templateId: args.templateId,
       brandSlug: args.brandSlug,
       contentType: args.contentType,
-      detail: args.detail ?? "focused",
+      detail,
       limit: 2
     });
+    const result = await applyLocalMotionLibraryOverride(remoteResult, detail);
     const images = [];
     const notes = [];
     if (args.includeReferenceFrames !== false && result.styles[0]?.scene) {
@@ -31966,7 +34502,8 @@ var TOOLS = [
   ...REMOTE_SAFE_TOOLS,
   getFramesTool,
   engineTypesTool,
-  motionContextTool
+  motionContextTool,
+  openStudioTool
 ];
 function toContent(output) {
   const content = [{ type: "text", text: output.text }];
@@ -32075,7 +34612,8 @@ function register(server, tool, ctx) {
     },
     async (args, extra) => {
       try {
-        const admission = ctx.admit && !UNMETERED_MCP_TOOLS.has(tool.name) ? await ctx.admit(tool.name) : null;
+        const admissionName = tool.admitAs ?? tool.name;
+        const admission = ctx.admit && !UNMETERED_MCP_TOOLS.has(admissionName) ? await ctx.admit(admissionName) : null;
         const execute = () => tool.handler(args ?? {}, ctx, toolProgress(extra));
         const output = admission?.receipt && ctx.withAdmission ? await ctx.withAdmission(admission.receipt, execute) : await execute();
         if (admission?.warning) output.text += `
@@ -32106,7 +34644,7 @@ ${formatUsageNotice(admission.warning)}`;
 }
 var ENGINE_DTS_URI = "impractical://engine.d.ts";
 function readEngineTypes() {
-  return readFileSync(fileURLToPath(new URL("../assets/engine.d.ts", import.meta.url)), "utf8");
+  return readFileSync2(fileURLToPath2(new URL("../assets/engine.d.ts", import.meta.url)), "utf8");
 }
 function registerEngineResource(server) {
   server.registerResource(
@@ -32122,9 +34660,17 @@ function registerEngineResource(server) {
     })
   );
 }
+function buildServerInstructions(ctx) {
+  return "Impractical Motion makes studio-quality motion-graphics videos. Draft source lives in the cloud \u2014 there is no working copy on disk, so edit through these tools rather than writing files.\n\nTHE USER'S EDITS COME FIRST. While watching a draft in the Studio the user queues timecoded edit requests into its notes.json (\"Edits for agent\"). Before directing an existing draft, read_draft_file notes.json (it may not exist \u2014 that is fine); address the open items, and mark each one you have handled by setting its `done` to true with edit_draft_file, leaving the rest of the entry intact. The Studio shows the user what you resolved.\n\nYou are the director. Call engine_types first to learn the API, then motion_context to study the current house library and production references, then create_video, then write App.tsx (the stage markup) and direction.ts (the GSAP choreography) with edit_draft_file / write_draft_files. Every save returns its committed revision and preview-build job id immediately. Follow that id with job_status and fix any build error it returns. Call get_frames to SEE the result before telling the user it is done, then call export_video, follow its returned job id with job_status, and hand the user the studio_link.\n\nJOBS OUTLIVE TOOL CALLS. Job-producing mutations return their durable job id BEFORE any wait; resume that exact id with job_status({ jobIds: [...], wait: true }). Never start a second export or re-apply an edit after a committed revision. If the MCP client kills a call and shows only a timeout, assume the acknowledgment may have been lost: DO NOT blindly retry a mutating or metered tool. Verify state first. For a write/edit, use list_draft_files and read_draft_file to confirm the intended source and revision. For an export or other project mutation, use get_project/list_projects to check whether it already started or completed. brand_extract returns a durable run handle; continue that exact jobId in status mode and never re-extract blindly. If its start acknowledgement is lost, check brand_list/brand_get before starting again. Retry only when those reads prove the mutation did not commit; otherwise continue from the observed state.\n\nTHE MOTION FLOOR \u2014 these hold even if you read nothing else:\n1. Beat out the story before writing code: every beat needs a time, a visible subject, and a narrative purpose. An intentional reading hold is a valid beat.\n2. Text enters on RISE \u2014 text.reveal(el, 'rise') on promo-out, lines ~0.2s apart. Do NOT default type to 'blur': word-by-word de-blur reads as out-of-focus and a staggered blur turns to mush. Blur is for whole-frame moves \u2014 fx.spike(el, 'blur') alongside a whip or dive, where it hides the cut. Never animate blur above 20px.\n3. Every ease is a named house curve \u2014 ease-out-* for entrances, ease-in-out-* for travel and ALL camera moves, ease-in-* for exits and dives only. Never leave an ease unspecified, and never put an ease-in-* on an entrance.\n4. Motion is decisive: entrances 0.4-0.6s, exits shorter, line staggers ~0.2s apart. Longer movement needs a narrative reason; important states may hold still to be read.\n5. One primary and at most one supporting motion at a time. Keep backgrounds stable unless their movement is explicitly authored. Cuts are HARD (tl.set), never crossfades.\n6. Determinism: no Date.now, Math.random, setTimeout, or CSS transitions. The exporter renders by seeking, so wall-clock motion shimmers or vanishes.\n7. Never claim a video is done without calling get_frames and judging the visible story, hierarchy, proof, legibility, reference fidelity, and technical integrity \u2014 artifact-free is not the same as good.\n" + // Item 8 is the content doctrine, which is still under experiment: it ships
+  // only when IMPRACTICAL_CONTENT_DOCTRINE is set, so the same switch governs
+  // the doctrine here and in the phased flow's phase 2.
+  (contentDoctrineEnabled() ? "8. CONTENT: pretend the viewer has never heard of this product. Figure out the one thing they should walk away knowing, and say it in as few words as possible. If a smart 16-year-old could not repeat a line back in their own words, the line means nothing \u2014 cut it. No buzzwords, no vague taglines. Say a thing, then show it happening \u2014 in that order, one after the other, never both at once. Give the viewer exactly one thing to read at a time: no little label above a headline, no subtitle under it." : "") + "\n9. ICONS: always use real icons from the icon library, never typographic or ASCII stand-ins. lucide-react is available in every draft \u2014 `import { ArrowRight, Check } from 'lucide-react'`. An arrow is <ArrowRight/>, not \u2192 or ->; a tick is <Check/>, not \u2713; a chevron is <ChevronRight/>, not >; a play control is <Play/>, not \u25B6. Glyphs inherit the text font, so they land on the baseline at the wrong weight and optical size and read as a placeholder, and they cannot take a stroke width or animate as their own element. The same goes for emoji standing in for a UI affordance.\n10. FOCAL BUDGET: one focal point at a time. At most ONE region of the frame changes at once (a full-frame camera move is one change; a subject plus its direct reaction is the limit). A claim and the product may NEVER share the same space: while a statement is up, the product is fully cleared or fully hidden \u2014 dimming it under the words is not separation. Never stack anything on top of a dashboard while the dashboard is the subject. An element that finished its job exits before the next enters; the motion report now measures split focus and stacked text, and the film is not done while either fires.\n11. COMPONENT REHEARSAL: build and judge the hero components BEFORE choreographing the film. For each component that must look real (the dashboard, the inbox, the editor): build it, render it with get_frames in each state the beats will put it through, compare it against the reference you studied, and iterate until it holds up as a still. Only then write the timeline. A component that cannot survive a paused frame will not survive motion, and choreographing a broken component wastes every revision that follows.\n12. SCALE TRUTH: a product element never exceeds its native proportion. When a toast, button, or label must be readable, push the CAMERA to it so the whole UI scales together \u2014 never blow one element up inside otherwise-small chrome; an oversized toast over tiny UI text reads as a fake. The same for pointers: a cursor or caret is sized relative to the UI it operates on (match the product's zoom factor; at 67% zoom the cursor is 67% size), a caret pins to its text baseline, and a cursor tip lands ON its target, never near it. The census measures inflated elements; the film is not done while it fires.\n13. PACING: slow down. Stillness is a tool, not a defect \u2014 the dead-air check finds UNOWNED time, not quiet time. After every claim and every proof, HOLD: the viewer needs settled time to focus before the next change. The motion report flags nonstop motion (TOO FAST) exactly like it flags dead air, and the film is not done while either fires. THE CADENCE: one action at a time, about one every 1\u20131.5 seconds \u2014 a click, a panel opening, a card landing each count as one action. Let each settle before the next. The kit and camera defaults are already tuned to this; never override their durations to be FASTER. The report measures action frequency and flags stretches that pack more.\n14. CUTS: a scene change lands ONLY on a declared beat boundary \u2014 never mid-beat, never mid-read. A transition is either a real camera move (the house dolly) or a hard cut covered by the incoming element; a 0.1\u20130.3s squash-collapse is neither. Vary how scenes leave \u2014 the same exit mechanism back to back reads as a loop, and a scene alive under ~2 seconds never registered. The motion score measures all of this." + (ctx.qualityLoop ? qualityLoopServerInstructions() : "") + (ctx.motionLab ? motionLabServerInstructions() : "") + (ctx.phasedFlow ? phasedServerInstructions() : "");
+}
 function createServer(ctx) {
+  const qualityLoopState = ctx.qualityLoop ? ctx.qualityLoopState ?? createQualityLoopState() : void 0;
   const validatedCtx = {
     ...ctx,
+    qualityLoopState,
     invoke: async (name, body = {}) => validateApiResponse(name, body, await ctx.invoke(name, body))
   };
   const server = new McpServer(
@@ -32136,10 +34682,17 @@ function createServer(ctx) {
       // agent that skips motion_context still cannot produce slop by default.
       // The full language (ease table, blur doctrine, camera grammar, beat
       // sheets) ships live in motion_context's `guidance.motionDirection`.
-      instructions: "Impractical Motion makes studio-quality motion-graphics videos. Draft source lives in the cloud \u2014 there is no working copy on disk, so edit through these tools rather than writing files.\n\nTHE USER'S EDITS COME FIRST. While watching a draft in the Studio the user queues timecoded edit requests into its notes.json (\"Edits for agent\"). Before directing an existing draft, read_draft_file notes.json (it may not exist \u2014 that is fine); address the open items, and mark each one you have handled by setting its `done` to true with edit_draft_file, leaving the rest of the entry intact. The Studio shows the user what you resolved.\n\nYou are the director. Call engine_types first to learn the API, then motion_context to study the current house library and production references, then create_video, then write App.tsx (the stage markup) and direction.ts (the GSAP choreography) with edit_draft_file / write_draft_files. Every save returns its committed revision and preview-build job id immediately. Follow that id with job_status and fix any build error it returns. Call get_frames to SEE the result before telling the user it is done, then call export_video, follow its returned job id with job_status, and hand the user the studio_link.\n\nJOBS OUTLIVE TOOL CALLS. Job-producing mutations return their durable job id BEFORE any wait; resume that exact id with job_status({ jobIds: [...], wait: true }). Never start a second export or re-apply an edit after a committed revision. If the MCP client kills a call and shows only a timeout, assume the acknowledgment may have been lost: DO NOT blindly retry a mutating or metered tool. Verify state first. For a write/edit, use list_draft_files and read_draft_file to confirm the intended source and revision. For an export or other project mutation, use get_project/list_projects to check whether it already started or completed. brand_extract returns a durable run handle; continue that exact jobId in status mode and never re-extract blindly. If its start acknowledgement is lost, check brand_list/brand_get before starting again. Retry only when those reads prove the mutation did not commit; otherwise continue from the observed state.\n\nTHE MOTION FLOOR \u2014 these hold even if you read nothing else:\n1. Beat out the story before writing code: every beat needs a time, a thing on screen, and a move. A beat with no move is not a beat.\n2. Text enters on RISE \u2014 text.reveal(el, 'rise') on promo-out, lines ~0.2s apart. Do NOT default type to 'blur': word-by-word de-blur reads as out-of-focus and a staggered blur turns to mush. Blur is for whole-frame moves \u2014 fx.spike(el, 'blur') alongside a whip or dive, where it hides the cut. Never animate blur above 20px.\n3. Every ease is a named house curve \u2014 ease-out-* for entrances, ease-in-out-* for travel and ALL camera moves, ease-in-* for exits and dives only. Never leave an ease unspecified, and never put an ease-in-* on an entrance.\n4. Motion is fast: entrances 0.4-0.6s, exits shorter, line staggers ~0.2s apart, nothing over 1s except a deliberate hold drift or slow push.\n5. Nothing is ever static \u2014 every hold carries a slow drift or camera push. Cuts are HARD (tl.set), never crossfades.\n6. Determinism: no Date.now, Math.random, setTimeout, or CSS transitions. The exporter renders by seeking, so wall-clock motion shimmers or vanishes.\n7. Never claim a video is done without calling get_frames and looking at the frames."
+      instructions: buildServerInstructions(ctx)
     }
   );
-  for (const tool of TOOLS) register(server, tool, validatedCtx);
+  const tools = [
+    ...TOOLS,
+    installKitsTool,
+    installFontTool,
+    ...ctx.motionLab ? [getMotionTool] : [],
+    ...ctx.phasedFlow ? [gatherReferencesTool] : []
+  ];
+  for (const tool of tools) register(server, tool, validatedCtx);
   registerEngineResource(server);
   return server;
 }
@@ -32155,14 +34708,19 @@ async function runStdioServer() {
     admit: admitMcpCall,
     withAdmission: withAdmissionReceipt,
     openExternal: openBrowser,
-    appUrl: config2.appUrl
+    appUrl: config2.appUrl,
+    qualityLoop: qualityLoopEnabled(),
+    motionLab: motionLabEnabled(),
+    phasedFlow: phasedFlowEnabled()
   });
   await server.connect(new StdioServerTransport());
-  process.stderr.write(`impractical mcp: serving ${TOOLS.length} tools over stdio
+  const served = TOOLS.length + 2 + (motionLabEnabled() ? 1 : 0) + (phasedFlowEnabled() ? 1 : 0);
+  process.stderr.write(`impractical mcp: serving ${served} tools over stdio
 `);
 }
 export {
   ENGINE_DTS_URI,
+  buildServerInstructions,
   createServer,
   runStdioServer
 };