@spark-apps/quickpeek 1.2.0 → 1.2.2

package/dist/mcp-tools.mjs

@@ -43,7 +43,7 @@ function getErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function toTitleCase(text) {
-  return text.replace(/\w+/g, (word, index) => {
+  return text.replace(/\w+(?:'\w+)*/g, (word, index) => {
     if (index === 0) {
       return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
     }
@@ -107,6 +107,23 @@ var init_utils = __esm({
 });
 
 // src/lib/api-client.ts
+function apiKey() {
+  return process.env.SPARK_AI_KEY || "";
+}
+function hostOf2(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "AI service";
+  }
+}
+function firstLine(text) {
+  return truncate((text ?? "").trim().split("\n")[0] ?? "", 200);
+}
+function truncate(text, max) {
+  const trimmed = (text ?? "").trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max)}\u2026` : trimmed;
+}
 async function getOrRefreshDirectToken() {
   const now = Date.now();
   if (cachedDirectToken && cachedDirectToken.expiresAt > now + 3e5) {
@@ -115,7 +132,7 @@ async function getOrRefreshDirectToken() {
   try {
     const response = await fetch(SPARK_AI_TOKEN, {
       method: "POST",
-      headers: { "X-Api-Key": API_KEY }
+      headers: { "X-Api-Key": apiKey() }
     });
     if (!response.ok) {
       throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
@@ -158,8 +175,10 @@ async function getOrRefreshRelayToken(email) {
     throw new Error(`Failed to get QuickPeek token: ${getErrorMessage(err)}`);
   }
 }
-async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier) {
-  let lastRateLimitError = null;
+async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier, opts = {}) {
+  const { onRetry, backoffMs = SERVER_BACKOFF_MS } = opts;
+  let lastRetriableError = null;
+  const host = hostOf2(chatUrl);
   for (let attempt = 1; attempt <= 3; attempt++) {
     try {
       const response = await fetch(chatUrl, {
@@ -175,36 +194,53 @@ async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier)
           ]
         })
       });
+      const bodyText = await response.text().catch(() => "");
       let data = {};
-      const contentType = response.headers.get("content-type") ?? "";
-      if (contentType.includes("application/json")) {
-        data = await response.json();
+      try {
+        data = bodyText ? JSON.parse(bodyText) : {};
+      } catch {
       }
       if (!response.ok) {
-        const error = data.error || `Spark AI error: ${response.status} ${response.statusText}`;
-        if (response.status === 429 && attempt < 3) {
-          const retryAfter = response.headers.get("Retry-After");
-          const delayMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 1e3 * 2 ** (attempt - 1);
-          lastRateLimitError = {
+        const upstream = data.error || firstLine(bodyText) || response.statusText || "no error body";
+        const error = `${host} ${response.status}: ${upstream}`;
+        const detail = truncate(bodyText, 800);
+        const isRetriable = response.status === 429 || response.status >= 500;
+        if (isRetriable && attempt < 3) {
+          const retryAfter2 = response.headers.get("Retry-After");
+          const delayMs = retryAfter2 ? parseInt(retryAfter2, 10) * 1e3 : response.status >= 500 ? backoffMs[attempt - 1] ?? backoffMs[backoffMs.length - 1] ?? 2e3 : 1e3 * 2 ** (attempt - 1);
+          onRetry?.({ attempt, status: response.status, delayMs, host });
+          lastRetriableError = {
             success: false,
             error,
-            isRateLimit: true,
-            ...retryAfter ? { retryAfterSeconds: parseInt(retryAfter, 10) } : {}
+            isRateLimit: response.status === 429,
+            status: response.status,
+            host,
+            ...detail ? { detail } : {},
+            ...retryAfter2 ? { retryAfterSeconds: parseInt(retryAfter2, 10) } : {}
           };
           await new Promise((resolve10) => setTimeout(resolve10, Math.min(delayMs, 3e4)));
           continue;
         }
+        const retryAfter = response.headers.get("Retry-After");
+        const retryAfterSeconds = retryAfter ? parseInt(retryAfter, 10) : Number.NaN;
         return {
           success: false,
           error,
           isRateLimit: response.status === 429,
-          isAuthError: response.status === 401 || response.status === 403
+          isAuthError: response.status === 401 || response.status === 403,
+          status: response.status,
+          host,
+          ...detail ? { detail } : {},
+          ...Number.isFinite(retryAfterSeconds) ? { retryAfterSeconds } : {}
         };
       }
       if (!data.success || !data.response) {
         return {
           success: false,
-          error: data.error || "No response from Spark AI"
+          error: `${host} 200 but no content: ${data.error || firstLine(bodyText) || "empty response"}`,
+          status: response.status,
+          host,
+          ...bodyText ? { detail: truncate(bodyText, 800) } : {}
         };
       }
       return {
@@ -218,15 +254,17 @@ async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier)
         }
       };
     } catch (err) {
-      if (attempt === 3) throw err;
+      if (attempt === 3) {
+        return { success: false, error: `${host} unreachable: ${getErrorMessage(err)}`, host };
+      }
       const delayMs = 1e3 * 2 ** (attempt - 1);
       await new Promise((resolve10) => setTimeout(resolve10, delayMs));
     }
   }
-  return lastRateLimitError || { success: false, error: "Request failed after retries" };
+  return lastRetriableError || { success: false, error: `${host}: request failed after retries`, host };
 }
-async function callAI(systemPrompt, userPrompt, tier = "free") {
-  if (!API_KEY) {
+async function callAI(systemPrompt, userPrompt, tier = "free", opts = {}) {
+  if (!apiKey()) {
     return {
       success: false,
       error: "AI service is not configured. Please report this issue.",
@@ -235,12 +273,12 @@ async function callAI(systemPrompt, userPrompt, tier = "free") {
   }
   try {
     const token = await getOrRefreshDirectToken();
-    return await executeChat(SPARK_AI_CHAT, token, systemPrompt, userPrompt, tier);
+    return await executeChat(SPARK_AI_CHAT, token, systemPrompt, userPrompt, tier, opts);
   } catch (err) {
     return { success: false, error: `Spark AI error: ${getErrorMessage(err)}` };
   }
 }
-async function callAIViaRelay(systemPrompt, userPrompt, email, tier = "free") {
+async function callAIViaRelay(systemPrompt, userPrompt, email, tier = "free", opts = {}) {
   if (!email) {
     return {
       success: false,
@@ -250,11 +288,11 @@ async function callAIViaRelay(systemPrompt, userPrompt, email, tier = "free") {
   }
   try {
     let token = await getOrRefreshRelayToken(email);
-    let result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier);
+    let result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier, opts);
     if (!result.success && result.isAuthError) {
       cachedRelayToken = null;
       token = await getOrRefreshRelayToken(email);
-      result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier);
+      result = await executeChat(RELAY_CHAT_URL, token, systemPrompt, userPrompt, tier, opts);
     }
     return result;
   } catch (err) {
@@ -286,18 +324,19 @@ function normalizeUrl(input) {
   url = url.replace(/^(https?:\/\/)?(www\.)?/i, "");
   return `https://${url}`;
 }
-var SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, RELAY_BASE, RELAY_TOKEN_URL, RELAY_CHAT_URL, API_KEY, cachedDirectToken, cachedRelayToken;
+var SERVER_BACKOFF_MS, CLI_BACKOFF_MS, SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, RELAY_BASE, RELAY_TOKEN_URL, RELAY_CHAT_URL, cachedDirectToken, cachedRelayToken;
 var init_api_client = __esm({
   "src/lib/api-client.ts"() {
     "use strict";
     init_utils();
+    SERVER_BACKOFF_MS = [2e3, 4e3];
+    CLI_BACKOFF_MS = [1e4, 3e4];
     SPARK_AI_BASE = "https://sparkbrain.app";
     SPARK_AI_CHAT = `${SPARK_AI_BASE}/api/chat`;
     SPARK_AI_TOKEN = `${SPARK_AI_BASE}/api/models/token`;
     RELAY_BASE = process.env.QUICKPEEK_API_BASE || "https://quickpeek.co";
     RELAY_TOKEN_URL = `${RELAY_BASE}/api/cli/token`;
     RELAY_CHAT_URL = `${RELAY_BASE}/api/cli/ai`;
-    API_KEY = process.env.SPARK_AI_KEY || "";
     cachedDirectToken = null;
     cachedRelayToken = null;
   }
@@ -322,7 +361,7 @@ async function getStatusCached(email) {
 function getTier(d) {
   if (!d.subscription || !d.registered) return "free";
   if (d.subscription.status === "canceled" || d.subscription.status === "past_due") return "free";
-  return TIERS[d.subscription.price_id] ?? "free";
+  return TIERS[d.subscription.price_id] ?? "pro";
 }
 async function getTierByEmail(email) {
   try {
@@ -339,17 +378,18 @@ async function isVerified(email) {
   }
 }
 function pricingUrl(opts) {
-  const u = new URL(`${BASE}/pricing/${APP_ID}`);
+  const u = new URL(`${BASE}/${OWNER_SLUG}/${APP_ID}`);
   if (opts?.email) u.searchParams.set("email", opts.email);
   if (opts?.returnUrl) u.searchParams.set("return_url", opts.returnUrl);
   return u.toString();
 }
-var APP_ID, BASE, TIERS, RANK, FEATURES, getStatus, _cache, isPaid, hasAccess, hasTrialRemaining, showPaywall, isCanceling;
+var APP_ID, OWNER_SLUG, BASE, TIERS, RANK, FEATURES, getStatus, _cache, isPaid, hasAccess, hasTrialRemaining, showPaywall, isCanceling;
 var init_SparkStripe_feature_gating = __esm({
   "src/lib/SparkStripe-feature-gating.ts"() {
     "use strict";
     APP_ID = process.env.SPARK_APP_ID ?? "quickpeek";
-    BASE = "https://sparkstripe.com";
+    OWNER_SLUG = process.env.SPARK_OWNER_SLUG ?? "spark";
+    BASE = "https://sparkpay.dev";
     TIERS = {
       price_1TADnPEf9opkuWid9NtqOYON: "pro",
       price_1TADnPEf9opkuWidgbvvX9ma: "pro",
@@ -401,7 +441,7 @@ var VERSION, CONFIG_FILE, DEFAULT_CONFIG, DEFAULT_CAPTIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
-    VERSION = "1.1.1";
+    VERSION = "1.2.1";
     CONFIG_FILE = "quickpeek.config.json";
     DEFAULT_CONFIG = {
       plan: { maxSteps: 8 },
@@ -551,7 +591,10 @@ var init_scraping = __esm({
 });
 
 // src/lib/crawl.ts
-import { chromium } from "playwright";
+import { chromium as chromium3 } from "playwright";
+function idSelector(id) {
+  return /^[A-Za-z_-][\w-]*$/.test(id) ? `#${id}` : `[id="${id.replace(/(["\\])/g, "\\$1")}"]`;
+}
 function getActionForType(type) {
   switch (type) {
     case "button":
@@ -569,20 +612,29 @@ function getActionForType(type) {
       return "type";
   }
 }
-async function crawlPage(url, task2 = noopTask, storageStatePath) {
-  const cached = crawlCache.get(url);
+async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
+  const cacheKey = viewport ? `${url}@${viewport.width}x${viewport.height}` : url;
+  const cached = crawlCache.get(cacheKey);
   if (cached && Date.now() - cached.timestamp < CRAWL_CACHE_TTL_MS) {
     task2("Using cached crawl").succeed(`Found ${cached.elements.length} interactive elements (cached)`);
-    return { title: cached.title, elements: [...cached.elements] };
+    return { title: cached.title, elements: [...cached.elements], scrollable: cached.scrollable };
   }
   const browserTask = task2("Launching browser");
-  const browser = await chromium.launch({ headless: true });
-  const context = await browser.newContext(storageStatePath ? { storageState: storageStatePath } : {});
+  const browser = await chromium3.launch({ headless: true });
+  const context = await browser.newContext({
+    ...storageStatePath ? { storageState: storageStatePath } : {},
+    // Crawl at the size we will record at, or the measurements below describe
+    // a page nobody will ever see.
+    ...viewport ? { viewport } : {}
+  });
   const page = await context.newPage();
   browserTask.succeed(storageStatePath ? "Browser launched (signed in)" : "Browser launched");
   const crawlTask = task2("Crawling page");
   await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
   const title = await page.title();
+  const scrollable = await page.evaluate(
+    "Math.max(0, document.documentElement.scrollHeight - window.innerHeight)"
+  );
   const rawElements = await page.evaluate(`
     (() => {
       const items = [];
@@ -672,9 +724,9 @@ async function crawlPage(url, task2 = noopTask, storageStatePath) {
     } else if (el.isFile || el.type === "file") {
       selector = 'input[type="file"]';
     } else if (el.type === "range") {
-      selector = el.id ? `#${el.id}` : 'input[type="range"]';
+      selector = el.id ? idSelector(el.id) : 'input[type="range"]';
     } else if (el.type === "checkbox") {
-      selector = el.id ? `#${el.id}` : 'input[type="checkbox"]';
+      selector = el.id ? idSelector(el.id) : 'input[type="checkbox"]';
     } else if (el.type === "button") {
       if (btnTexts[el.text] === 1) {
         selector = `text="${el.text}"`;
@@ -684,7 +736,7 @@ async function crawlPage(url, task2 = noopTask, storageStatePath) {
     } else if (el.type === "link") {
       selector = `text="${el.text}"`;
     } else if (el.id) {
-      selector = `#${el.id}`;
+      selector = idSelector(el.id);
     } else if (el.name) {
       selector = `[name="${el.name}"]`;
     } else if (el.placeholder) {
@@ -712,12 +764,12 @@ async function crawlPage(url, task2 = noopTask, storageStatePath) {
   });
   await browser.close();
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
-  crawlCache.set(url, { timestamp: Date.now(), title, elements: [...elements] });
+  crawlCache.set(cacheKey, { timestamp: Date.now(), title, elements: [...elements], scrollable });
   if (crawlCache.size > CRAWL_CACHE_MAX_ENTRIES) {
     const oldest = crawlCache.keys().next().value;
     if (oldest !== void 0) crawlCache.delete(oldest);
   }
-  return { title, elements };
+  return { title, elements, scrollable };
 }
 var noopTask, CRAWL_CACHE_TTL_MS, CRAWL_CACHE_MAX_ENTRIES, crawlCache;
 var init_crawl = __esm({
@@ -771,7 +823,7 @@ var init_watermark = __esm({
 });
 
 // src/lib/ffmpeg/spawn.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function toWSLPath(path) {
   if (!isWindowsRuntime) return path;
   return windowsDrivePathToWsl(path) ?? path.replace(/\\/g, "/");
@@ -785,9 +837,9 @@ function convertArgToWSL(arg2) {
 function spawnFFmpeg(cmd2, args) {
   if (isWindowsRuntime) {
     const wslArgs = args.map(convertArgToWSL);
-    return spawn("wsl", ["-e", cmd2, ...wslArgs]);
+    return spawn2("wsl", ["-e", cmd2, ...wslArgs]);
   }
-  return spawn(cmd2, args);
+  return spawn2(cmd2, args);
 }
 function runFFmpeg(args, errorLabel) {
   return new Promise((resolve10, reject) => {
@@ -986,8 +1038,39 @@ function getMediaDuration(filePath) {
     proc.on("error", reject);
   });
 }
+function getAudioCodec(filePath) {
+  return new Promise((resolve10) => {
+    const args = [
+      "-v",
+      "error",
+      "-select_streams",
+      "a:0",
+      "-show_entries",
+      "stream=codec_name",
+      "-of",
+      "default=noprint_wrappers=1:nokey=1",
+      filePath
+    ];
+    const proc = spawnFFmpeg("ffprobe", args);
+    let stdout = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data;
+    });
+    proc.on("close", (code) => resolve10(code === 0 ? stdout.trim() : ""));
+    proc.on("error", () => resolve10(""));
+  });
+}
+async function isHonestWav(filePath) {
+  const codec = await getAudioCodec(filePath);
+  return codec.startsWith("pcm_");
+}
+function buildConcatArgs(listPath, output) {
+  const isWav = output.toLowerCase().endsWith(".wav");
+  const codec = isWav ? ["-c:a", "pcm_s16le"] : ["-c", "copy"];
+  return ["-y", "-f", "concat", "-safe", "0", "-i", listPath, ...codec, output];
+}
 function concatMedia(listPath, output) {
-  return runFFmpeg(["-y", "-f", "concat", "-safe", "0", "-i", listPath, "-c", "copy", output], "ffmpeg concat failed");
+  return runFFmpeg(buildConcatArgs(listPath, output), "ffmpeg concat failed");
 }
 function generateSilence(outputPath, durationMs) {
   return runFFmpeg(
@@ -1236,6 +1319,114 @@ var init_ffmpeg2 = __esm({
   }
 });
 
+// src/lib/json-repair.ts
+function repairUnicodeEscapes(content) {
+  return content.replace(/\\u\{([0-9a-fA-F]{1,6})\}/g, (match, hex) => {
+    const code = Number.parseInt(hex, 16);
+    return code <= 1114111 ? String.fromCodePoint(code) : match;
+  }).replace(/\\u(?![0-9a-fA-F]{4})/g, "\\\\u");
+}
+function salvageTruncatedJson(content) {
+  const stack = [];
+  const cuts = [];
+  let inString = false;
+  let escaped = false;
+  const record = (index, closesContainer) => cuts.push({ index, open: stack.join(""), closesContainer });
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') {
+        inString = false;
+        record(i + 1, false);
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      record(i + 1, true);
+    } else if (ch === ",") {
+      record(i, content[i - 1] === "}" || content[i - 1] === "]");
+    }
+  }
+  const tryCut = (cut) => {
+    const head = content.slice(0, cut.index).replace(/[\s,]+$/, "");
+    if (head.endsWith(":")) return null;
+    let closed = head;
+    for (let d = cut.open.length - 1; d >= 0; d--) {
+      closed += CLOSERS[cut.open[d]];
+    }
+    try {
+      JSON.parse(closed);
+      return closed;
+    } catch {
+      return null;
+    }
+  };
+  const attempts = Math.min(cuts.length, MAX_SALVAGE_ATTEMPTS);
+  for (const containerOnly of [true, false]) {
+    for (let n = 0; n < attempts; n++) {
+      const cut = cuts[cuts.length - 1 - n];
+      if (containerOnly && !cut.closesContainer) continue;
+      const salvaged = tryCut(cut);
+      if (salvaged !== null) return salvaged;
+    }
+  }
+  return null;
+}
+function extractJsonCandidates(content) {
+  let text = content.trim();
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)(?:```|$)/);
+  if (fence?.[1]?.trim()) text = fence[1].trim();
+  const start = text.search(/[{[]/);
+  if (start === -1) return [];
+  const closer = text[start] === "{" ? "}" : "]";
+  const end = text.lastIndexOf(closer);
+  const candidates = [text.slice(start)];
+  if (end > start && end < text.length - 1) candidates.unshift(text.slice(start, end + 1));
+  return candidates;
+}
+function parseAIJson(content) {
+  const candidates = extractJsonCandidates(content);
+  if (candidates.length === 0) return null;
+  for (const text of candidates) {
+    try {
+      return { value: JSON.parse(text), repaired: false };
+    } catch {
+    }
+  }
+  for (const text of candidates) {
+    try {
+      return { value: JSON.parse(repairUnicodeEscapes(text)), repaired: true };
+    } catch {
+    }
+  }
+  for (const text of candidates) {
+    for (const variant of [repairUnicodeEscapes(text), text]) {
+      const salvaged = salvageTruncatedJson(variant);
+      if (salvaged === null) continue;
+      try {
+        return { value: JSON.parse(salvaged), repaired: true };
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+var MAX_SALVAGE_ATTEMPTS, CLOSERS;
+var init_json_repair = __esm({
+  "src/lib/json-repair.ts"() {
+    "use strict";
+    MAX_SALVAGE_ATTEMPTS = 500;
+    CLOSERS = { "{": "}", "[": "]" };
+  }
+});
+
 // src/lib/prompts.ts
 function buildSystemPrompt(maxSteps) {
   let scope;
@@ -1289,7 +1480,7 @@ EXAMPLES:
 \u2022 File upload: "target": "input[type=\\"file\\"]"
 \u2022 Slider: "target": "input[type=\\"range\\"]"`;
 }
-function buildUserPrompt(url, title, elements, langName, description, maxSteps) {
+function buildUserPrompt(url, title, elements, langName, description, maxSteps, scrollable) {
   const lang = langName ? `
 Language: Write ALL captions in ${langName}.` : "";
   const purpose = description ? `
@@ -1327,8 +1518,13 @@ ${selectables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`
 ${checkables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`);
   }
   const elementSummary = elementDict.length > 0 ? elementDict.join("\n\n") : "(no interactive elements found)";
+  const cannotScroll = scrollable !== void 0 && scrollable < MIN_USEFUL_SCROLL_PX;
+  const scrolling = cannotScroll ? `
+
+SCROLLING: this page has only ${scrollable}px of scroll travel at the recording size, so it does not scroll.` : "";
+  const scrollRule = cannotScroll ? "\n\u2022 NEVER use the scroll action: this page does not scroll, so the video would freeze. Use wait and click steps only" : "";
   return `URL: ${url}
-Title: ${title}${purpose}
+Title: ${title}${purpose}${scrolling}
 
 AVAILABLE ELEMENTS (grouped by action):
 ${elementSummary}
@@ -1338,7 +1534,7 @@ REQUIREMENTS:
 \u2022 Complete ONE user journey: input \u2192 process \u2192 output
 \u2022 For CLICK: use simplified text target like "extract frame" or "download"
 \u2022 For UPLOAD/DRAG/TYPE: use the CSS selector shown above
-\u2022 For buttons that appear after actions: use partial text like "extract" or "download"${lang}
+\u2022 For buttons that appear after actions: use partial text like "extract" or "download"${scrollRule}${lang}
 
 Return JSON:
 {
@@ -1361,10 +1557,12 @@ TARGET SYNTAX:
 \u2022 Sliders: input[type="range"]
 \u2022 Text inputs: Use selector from list above`;
 }
+var MIN_USEFUL_SCROLL_PX;
 var init_prompts = __esm({
   "src/lib/prompts.ts"() {
     "use strict";
     init_utils();
+    MIN_USEFUL_SCROLL_PX = 200;
   }
 });
 
@@ -1430,7 +1628,7 @@ var init_styles = __esm({
 async function registerFreeUser(email) {
   const APP_ID2 = process.env.SPARK_APP_ID ?? "quickpeek";
   try {
-    const response = await fetch(`https://sparkstripe.com/api/register-free`, {
+    const response = await fetch(`https://sparkpay.dev/api/register-free`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ email, app_id: APP_ID2, app_name: "QuickPeek" })
@@ -1465,7 +1663,7 @@ var init_subscription_client = __esm({
 });
 
 // src/lib/tts/helpers.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { readFile, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
 import { isAbsolute, join as join2, resolve as resolve2 } from "path";
 function toWSLPathForTTS(path) {
@@ -1500,7 +1698,7 @@ async function getMediaStepDuration(step, baseDir) {
     return 0;
   }
   const mediaPath = isAbsolute(step.value) ? step.value : resolve2(baseDir, step.value);
-  if (!existsSync3(mediaPath)) {
+  if (!existsSync4(mediaPath)) {
     return 0;
   }
   try {
@@ -1522,7 +1720,7 @@ async function getMediaStepDuration(step, baseDir) {
 async function loadVoiceoverMeta(outputDir) {
   const metaPath = join2(outputDir, "voiceover.json");
   try {
-    if (!existsSync3(metaPath)) return null;
+    if (!existsSync4(metaPath)) return null;
     const content = await readFile(metaPath, "utf-8");
     return JSON.parse(content);
   } catch {
@@ -1561,7 +1759,7 @@ __export(timing_exports, {
   alignVoiceoverToRecording: () => alignVoiceoverToRecording,
   estimateWordTimings: () => estimateWordTimings
 });
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { join as join3 } from "path";
 function estimateWordTimings(caption, duration) {
   const words = caption.split(/\s+/).filter((w) => w.length > 0);
@@ -1598,9 +1796,9 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
     const audioPath = join3(audioDir, `step-${stepNum}.mp3`);
     const originalPaddingPath = join3(audioDir, `step-${stepNum}-padding.mp3`);
     const silencePath = join3(audioDir, `step-${stepNum}-silence.mp3`);
-    if (existsSync4(audioPath)) {
+    if (existsSync5(audioPath)) {
       segments.push(audioPath);
-      if (existsSync4(originalPaddingPath)) {
+      if (existsSync5(originalPaddingPath)) {
         segments.push(originalPaddingPath);
       }
       if (recordingDuration > voiceDuration) {
@@ -1608,7 +1806,7 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
         await generateSilence(alignPaddingPath, recordingDuration - voiceDuration);
         segments.push(alignPaddingPath);
       }
-    } else if (existsSync4(silencePath)) {
+    } else if (existsSync5(silencePath)) {
       if (targetDuration !== voiceDuration) {
         await generateSilence(silencePath, targetDuration);
       }
@@ -1696,10 +1894,25 @@ var init_voices = __esm({
 
 // src/lib/tts/synthesize.ts
 import { exec } from "child_process";
-import { writeFile as writeFile3 } from "fs/promises";
+import { createWriteStream } from "fs";
+import { stat, unlink as unlink3, writeFile as writeFile3 } from "fs/promises";
 import { join as join5, resolve as resolve3 } from "path";
+import { pipeline } from "stream/promises";
 import { promisify } from "util";
 async function synthesizeSpeech(text, outputPath, voice) {
+  let pythonMsg = "";
+  for (let attempt = 0; attempt < PYTHON_ATTEMPTS; attempt++) {
+    try {
+      await synthesizeWithPython(text, outputPath, voice);
+      return;
+    } catch (err) {
+      pythonMsg = err instanceof Error ? err.message : String(err);
+      if (attempt < PYTHON_ATTEMPTS - 1) await new Promise((r) => setTimeout(r, 500));
+    }
+  }
+  await synthesizeWithNode(text, outputPath, voice, pythonMsg);
+}
+async function synthesizeWithPython(text, outputPath, voice) {
   const tempScriptPath = join5(resolve3(outputPath, ".."), `tts-${Date.now()}.py`);
   const wslScriptPath = isWindows ? toWSLPathForTTS(resolve3(tempScriptPath)) : tempScriptPath;
   const wslOutputPath = isWindows ? toWSLPathForTTS(resolve3(outputPath)) : outputPath;
@@ -1720,42 +1933,45 @@ asyncio.run(main())
     await writeFile3(tempScriptPath, pythonScript);
     const pythonCmd = isWindows ? `wsl python3 "${wslScriptPath}"` : `python3 "${wslScriptPath}"`;
     await execAsync(pythonCmd, { timeout: 3e4 });
-    await import("fs/promises").then((fs) => fs.unlink(tempScriptPath).catch(() => {
-    }));
-    return;
-  } catch (pythonErr) {
-    await import("fs/promises").then((fs) => fs.unlink(tempScriptPath).catch(() => {
-    }));
-    const pythonMsg = pythonErr instanceof Error ? pythonErr.message : String(pythonErr);
-    const maxRetries = 2;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        const { MsEdgeTTS, OUTPUT_FORMAT } = await import("msedge-tts");
-        const tts = new MsEdgeTTS();
-        await tts.setMetadata(voice, OUTPUT_FORMAT.AUDIO_24KHZ_96KBITRATE_MONO_MP3);
-        await tts.toFile(outputPath, text);
-        return;
-      } catch (nodeErr) {
-        if (attempt === maxRetries) {
-          const nodeMsg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
-          throw new Error(`TTS failed (Python: ${pythonMsg.slice(0, 100)}, Node: ${nodeMsg.slice(0, 100)})`);
-        }
-        await new Promise((r) => setTimeout(r, 500));
+  } finally {
+    await unlink3(tempScriptPath).catch(() => {
+    });
+  }
+}
+async function synthesizeWithNode(text, outputPath, voice, pythonMsg, maxRetries = 2) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const { MsEdgeTTS, OUTPUT_FORMAT } = await import("msedge-tts");
+      const tts = new MsEdgeTTS();
+      await tts.setMetadata(voice, OUTPUT_FORMAT.AUDIO_24KHZ_96KBITRATE_MONO_MP3);
+      const { audioStream } = tts.toStream(text);
+      await pipeline(audioStream, createWriteStream(outputPath));
+      const { size } = await stat(outputPath);
+      if (size === 0) throw new Error("No audio data received");
+      return;
+    } catch (nodeErr) {
+      await unlink3(outputPath).catch(() => {
+      });
+      if (attempt === maxRetries) {
+        const nodeMsg = nodeErr instanceof Error ? nodeErr.message : String(nodeErr);
+        throw new Error(`TTS failed (Python: ${pythonMsg.slice(0, 100)}, Node: ${nodeMsg.slice(0, 100)})`);
       }
+      await new Promise((r) => setTimeout(r, 500));
     }
   }
 }
-var execAsync;
+var execAsync, PYTHON_ATTEMPTS;
 var init_synthesize = __esm({
   "src/lib/tts/synthesize.ts"() {
     "use strict";
     init_helpers();
     execAsync = promisify(exec);
+    PYTHON_ATTEMPTS = 2;
   }
 });
 
 // src/lib/tts/generate.ts
-import { mkdir as mkdir2 } from "fs/promises";
+import { mkdir as mkdir3 } from "fs/promises";
 import { join as join6 } from "path";
 function estimateDurationFromText(text, wordsPerMinute = 150) {
   const words = text.split(/\s+/).filter((w) => w.length > 0).length;
@@ -1789,7 +2005,7 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     return { voiceoverPath: "", stepAudio: stepAudio2 };
   }
   const audioDir = join6(workDir, "audio");
-  await mkdir2(audioDir, { recursive: true });
+  await mkdir3(audioDir, { recursive: true });
   const segments = [];
   const stepAudio = /* @__PURE__ */ new Map();
   const ttsTask = task2("Generating voiceover");
@@ -1840,7 +2056,7 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     return { voiceoverPath: "", stepAudio };
   }
   const concatTask = task2("Combining audio");
-  await mkdir2(outputDir, { recursive: true });
+  await mkdir3(outputDir, { recursive: true });
   const voiceoverPath = join6(outputDir, "voiceover.wav");
   await concatenateAudio(segments, voiceoverPath, workDir);
   concatTask.succeed("Done");
@@ -1902,6 +2118,7 @@ var init_types3 = __esm({
 // src/lib/index.ts
 var lib_exports = {};
 __export(lib_exports, {
+  CLI_BACKOFF_MS: () => CLI_BACKOFF_MS,
   CONFIG_FILE: () => CONFIG_FILE,
   CURSOR_CSS: () => CURSOR_CSS,
   CURSOR_PNG: () => CURSOR_PNG,
@@ -1912,9 +2129,11 @@ __export(lib_exports, {
   FEATURES: () => FEATURES,
   INTERACTIVE_SELECTORS: () => INTERACTIVE_SELECTORS,
   LANGUAGE_VOICES: () => WIDE_VOICES,
+  SERVER_BACKOFF_MS: () => SERVER_BACKOFF_MS,
   VERSION: () => VERSION,
   alignVoiceoverToRecording: () => alignVoiceoverToRecording,
   applyTransitions: () => applyTransitions,
+  buildConcatArgs: () => buildConcatArgs,
   buildKeepSegments: () => buildKeepSegments,
   buildStepTransitions: () => buildStepTransitions,
   buildSystemPrompt: () => buildSystemPrompt,
@@ -1928,9 +2147,11 @@ __export(lib_exports, {
   concatVideoWithOutro: () => concatVideoWithOutro,
   crawlPage: () => crawlPage,
   estimateWordTimings: () => estimateWordTimings,
+  extractJsonCandidates: () => extractJsonCandidates,
   generateASSHeader: () => generateASSHeader,
   generateSilence: () => generateSilence,
   generateVoiceover: () => generateVoiceover,
+  getAudioCodec: () => getAudioCodec,
   getErrorMessage: () => getErrorMessage,
   getLanguageName: () => getLanguageName,
   getMediaDuration: () => getMediaDuration,
@@ -1941,20 +2162,25 @@ __export(lib_exports, {
   hasAccess: () => hasAccess,
   hasTrialRemaining: () => hasTrialRemaining,
   hexToASS: () => hexToAss,
+  idSelector: () => idSelector,
   isCanceling: () => isCanceling,
   isExcludedLink: () => isExcludedLink,
+  isHonestWav: () => isHonestWav,
   isPaid: () => isPaid,
   isVerified: () => isVerified,
   loadExistingVoiceover: () => loadExistingVoiceover,
   loadVoiceoverMeta: () => loadVoiceoverMeta,
   mapTimestampsAfterCompression: () => mapTimestampsAfterCompression,
   normalizeUrl: () => normalizeUrl,
+  parseAIJson: () => parseAIJson,
   parseAIPlanResponse: () => parseAIPlanResponse,
   parsePartial: () => parsePartial,
   pricingUrl: () => pricingUrl,
   registerFreeUser: () => registerFreeUser,
+  repairUnicodeEscapes: () => repairUnicodeEscapes,
   resolveVoice: () => resolveVoice,
   rgbaToHex: () => rgbaToHex,
+  salvageTruncatedJson: () => salvageTruncatedJson,
   shouldSkipLink: () => shouldSkipLink,
   shouldWatermark: () => shouldWatermark,
   showPaywall: () => showPaywall,
@@ -1973,6 +2199,7 @@ var init_lib = __esm({
     init_crawl();
     init_cursor();
     init_ffmpeg2();
+    init_json_repair();
     init_prompts();
     init_SparkStripe_feature_gating();
     init_scraping();
@@ -1996,13 +2223,13 @@ __export(config_loader_exports, {
   savePlan: () => savePlan,
   saveUserData: () => saveUserData
 });
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir3, readFile as readFile2, rm, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir4, readFile as readFile2, rm, writeFile as writeFile4 } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { dirname, join as join7 } from "path";
 async function loadConfig(_url, langOverride) {
   const configPath = join7(process.cwd(), CONFIG_FILE);
-  if (existsSync5(configPath)) {
+  if (existsSync6(configPath)) {
     try {
       const content = await readFile2(configPath, "utf-8");
       const userConfig = JSON.parse(content);
@@ -2052,15 +2279,15 @@ async function loadConfig(_url, langOverride) {
 }
 async function prepareWorkDir() {
   const workDir = join7(process.cwd(), WORK_DIR);
-  if (existsSync5(workDir)) {
+  if (existsSync6(workDir)) {
     await rm(workDir, { recursive: true });
   }
-  await mkdir3(workDir, { recursive: true });
+  await mkdir4(workDir, { recursive: true });
   return workDir;
 }
 async function loadUserData() {
   try {
-    if (existsSync5(USER_DATA_FILE)) {
+    if (existsSync6(USER_DATA_FILE)) {
       return JSON.parse(await readFile2(USER_DATA_FILE, "utf-8"));
     }
   } catch {
@@ -2068,8 +2295,8 @@ async function loadUserData() {
   return {};
 }
 async function saveUserData(userData) {
-  if (!existsSync5(USER_DATA_DIR)) {
-    await mkdir3(USER_DATA_DIR, { recursive: true });
+  if (!existsSync6(USER_DATA_DIR)) {
+    await mkdir4(USER_DATA_DIR, { recursive: true });
   }
   const existing = await loadUserData();
   const merged = { ...existing, ...userData };
@@ -2122,7 +2349,7 @@ function parseCaptionCSS(css) {
 }
 async function loadCaptions() {
   const captionsPath = join7(process.cwd(), "captions.css");
-  if (!existsSync5(captionsPath)) {
+  if (!existsSync6(captionsPath)) {
     await writeFile4(captionsPath, DEFAULT_CAPTIONS_CSS);
     return DEFAULT_CAPTIONS;
   }
@@ -2138,7 +2365,7 @@ async function savePlan(plan, planPath) {
     ...plan,
     steps: plan.steps.map(({ duration, ...step }) => step)
   };
-  await mkdir3(dirname(planPath), { recursive: true });
+  await mkdir4(dirname(planPath), { recursive: true });
   await writeFile4(planPath, JSON.stringify(cleanPlan, null, 2));
 }
 var WORK_DIR, USER_DATA_DIR, USER_DATA_FILE, DEFAULT_CAPTIONS_CSS;
@@ -2246,16 +2473,16 @@ function fileResult(output, data, poster) {
 }
 
 // src/mcp/tools.ts
-import { readdirSync as readdirSync4, statSync as statSync2 } from "fs";
-import { join as join22 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { join as join23 } from "path";
 import { WIDE_VOICES as WIDE_VOICES2 } from "@spark-apps/video-kit";
 
 // src/browser/auth-state.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { chmod, mkdir, readdir, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { join } from "path";
-var AUTH_DIR = join(homedir(), ".quickpeek", "auth");
+var AUTH_DIR = process.env.QUICKPEEK_AUTH_DIR || join(homedir(), ".quickpeek", "auth");
 function hostOf(url) {
   try {
     return new URL(url).host;
@@ -2267,145 +2494,551 @@ function authStatePath(url) {
   const host = hostOf(url);
   return host ? join(AUTH_DIR, `${host}.json`) : null;
 }
+function authMetaPath(url) {
+  const host = hostOf(url);
+  return host ? join(AUTH_DIR, `${host}.meta.json`) : null;
+}
 function findAuthState(url) {
   const path = authStatePath(url);
   return path && existsSync2(path) ? path : void 0;
 }
-
-// src/commands/record-cmd.ts
-import { existsSync as existsSync17 } from "fs";
-import { mkdir as mkdir8 } from "fs/promises";
-import { isAbsolute as isAbsolute5, join as join20, resolve as resolve9 } from "path";
-import chalk14 from "chalk";
-
-// src/help.ts
-init_lib();
-import chalk from "chalk";
-
-// src/logo.ts
-import figlet from "figlet";
-import gradient from "gradient-string";
-var DEFAULT_LOGO_CONFIG = {
-  text: "QuickPeek",
-  font: "Slant",
-  horizontalLayout: "default",
-  gradientColors: ["#00ffff", "#00d4ff", "#a855f7", "#ec4899"],
-  suffix: " \u{1F440}"
-};
-function renderLogo(config = {}) {
-  const resolved = { ...DEFAULT_LOGO_CONFIG, ...config };
-  const ascii = figlet.textSync(resolved.text, {
-    font: resolved.font,
-    horizontalLayout: resolved.horizontalLayout
-  });
-  const colored = gradient(resolved.gradientColors)(ascii);
-  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
-}
-
-// src/help.ts
-init_config_loader();
-var cmd = chalk.cyan;
-var arg = chalk.green;
-var opt = chalk.magenta;
-var desc = chalk.white;
-var ex = chalk.dim;
-function showLogo() {
-  const logo = renderLogo();
-  console.log(logo);
-  console.log(chalk.dim(`  v${VERSION} - Auto-generate demo videos with AI`));
-  console.log(chalk.italic.dim("  Because Tutorial Videos are Overrated!\n"));
-}
-function formatUsageLines(status, tier) {
-  const lines = [];
-  lines.push(`Videos generated: ${status.usage_count}`);
-  if (tier !== "pro" && status.trial) {
-    const { uses_remaining, max_uses, days_remaining, is_expired } = status.trial;
-    const used = max_uses - uses_remaining;
-    lines.push(`Trial: ${used}/${max_uses} uses${is_expired ? " (expired)" : ` (${uses_remaining} remaining)`}`);
-    if (!is_expired && days_remaining > 0) {
-      lines.push(`Trial ends in ${days_remaining} day${days_remaining === 1 ? "" : "s"}`);
-    }
-  }
-  if (tier === "pro" && status.subscription) {
-    const end = status.subscription.current_period_end;
-    if (status.subscription.is_lifetime) {
-      lines.push("Lifetime access");
-    } else if (isCanceling(status)) {
-      const date = new Date(end).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
-      lines.push(`Cancels: ${date}`);
-    } else if (end) {
-      const date = new Date(end).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
-      lines.push(`Renews: ${date}`);
-    }
+async function saveAuthState(url, state, startUrl) {
+  const path = authStatePath(url);
+  if (!path) throw new Error(`Not a valid URL: ${url}`);
+  await mkdir(AUTH_DIR, { recursive: true });
+  await writeFile(path, JSON.stringify(state, null, 2));
+  await chmod(path, 384);
+  if (startUrl) {
+    await writeFile(authMetaPath(url), JSON.stringify({ startUrl, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  }
+  return path;
+}
+function findStartUrl(url) {
+  const path = authMetaPath(url);
+  if (!path || !existsSync2(path)) return void 0;
+  try {
+    const startUrl = JSON.parse(readFileSync2(path, "utf8")).startUrl;
+    return typeof startUrl === "string" && startUrl.startsWith("http") ? startUrl : void 0;
+  } catch {
+    return void 0;
   }
-  return lines;
 }
-
-// src/commands/record-cmd.ts
-init_lib();
-init_config_loader();
-
-// src/utils/logging.ts
-import { appendFile, writeFile as writeFile5 } from "fs/promises";
-import { join as join8 } from "path";
-var LOG_FILE_NAME = "quickpeek.log";
-var logFileInitialized = false;
-var logFilePath = LOG_FILE_NAME;
-async function writeLogEntry(entry) {
+function resolveStartUrl(url) {
   try {
-    if (!logFileInitialized) {
-      await writeFile5(logFilePath, entry);
-      logFileInitialized = true;
-    } else {
-      await appendFile(logFilePath, entry);
-    }
+    const parsed = new URL(url);
+    const bareOrigin = (parsed.pathname === "/" || parsed.pathname === "") && !parsed.search && !parsed.hash;
+    if (!bareOrigin || !findAuthState(url)) return url;
+    return findStartUrl(url) ?? url;
   } catch {
+    return url;
   }
 }
-async function setLogFilePath(outputDir) {
-  logFilePath = join8(outputDir, LOG_FILE_NAME);
-  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
-${"=".repeat(60)}
 
-`;
+// src/browser/launch.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { chromium as chromium2 } from "playwright";
+
+// src/browser/wsl.ts
+import { execSync, spawn } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { request } from "http";
+import { chromium } from "playwright";
+function isWSL() {
+  if (process.platform !== "linux") return false;
   try {
-    await writeFile5(logFilePath, header2);
-    logFileInitialized = true;
+    const r = execSync("uname -r", { encoding: "utf-8" }).toLowerCase();
+    return r.includes("microsoft") || r.includes("wsl");
   } catch {
+    return false;
   }
 }
-async function logInfo(context, message) {
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [${context}] ${message}
-`);
+function tryEnableWSLInterop() {
+  return existsSync3("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
-async function logDebug(context, message) {
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [${context}] ${message}
-`);
+function wslToWindowsPath(wslPath) {
+  if (!wslPath) return wslPath;
+  const m = wslPath.match(/^\/mnt\/([a-z])\/(.*)/);
+  if (!m) return wslPath;
+  return `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, "\\")}`;
 }
-async function logError(context, error) {
-  let errorMsg;
-  if (error instanceof Error) {
-    errorMsg = `${error.message}
-${error.stack}`;
-  } else if (typeof error === "object" && error !== null) {
-    errorMsg = JSON.stringify(error, null, 2);
-  } else {
-    errorMsg = String(error);
+function findExe(whereExeQuery, ...hardcoded) {
+  for (const p of hardcoded) if (existsSync3(p)) return p;
+  try {
+    const line = execSync(`where.exe ${whereExeQuery}`, { encoding: "utf-8", timeout: 3e3 }).split("\n")[0]?.trim();
+    if (line) return line.replace(/^([A-Za-z]):\\/, (_, d) => `/mnt/${d.toLowerCase()}/`).replace(/\\/g, "/");
+  } catch {
   }
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] [${context}]
-${errorMsg}
-
-`);
+  return null;
 }
-async function logStep(stepNum, action, details) {
-  const detailsStr = Object.entries(details).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [STEP ${stepNum}] ${action} | ${detailsStr}
-`);
+var findWindowsChrome = () => findExe(
+  "chrome.exe",
+  "/mnt/c/Program Files/Google/Chrome/Application/chrome.exe",
+  "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"
+);
+var findWindowsNode = () => findExe("node.exe");
+function getWindowsHostIP() {
+  try {
+    const m = execSync("ip route show default", { encoding: "utf-8", timeout: 2e3 }).match(
+      /default via (\d+\.\d+\.\d+\.\d+)/
+    );
+    if (m?.[1]) return m[1];
+  } catch {
+  }
+  try {
+    const m = readFileSync3("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+    if (m?.[1]) return m[1];
+  } catch {
+  }
+  return "127.0.0.1";
 }
-
-// src/utils/ui.ts
-import { resolve as resolve4 } from "path";
-import { createInterface } from "readline";
+function startRelay(nodePath, windowsHost, targetPort) {
+  const script = `var n=require('net'),s=n.createServer(function(c){var r=n.createConnection(${targetPort},'127.0.0.1');c.pipe(r);r.pipe(c);r.on('error',function(){c.destroy()});c.on('error',function(){r.destroy()});});s.listen(0,'${windowsHost}',function(){process.stdout.write('PORT:'+s.address().port+'\\n')});`;
+  return new Promise((resolve10, reject) => {
+    const proc = spawn(nodePath, ["-e", script], { stdio: ["ignore", "pipe", "ignore"], detached: true });
+    const timer = setTimeout(() => reject(new Error("relay startup timed out")), 6e3);
+    let buf = "";
+    proc.stdout.on("data", (d) => {
+      buf += d.toString();
+      const m = buf.match(/PORT:(\d+)/);
+      if (m) {
+        clearTimeout(timer);
+        resolve10({ proc, port: +m[1] });
+      }
+    });
+    proc.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
+}
+function waitForChrome(host, port) {
+  return new Promise((resolve10, reject) => {
+    const deadline = Date.now() + 2e4;
+    const poll = () => {
+      if (Date.now() > deadline) {
+        reject(new Error("Chrome debug port did not open within 20 s"));
+        return;
+      }
+      const req = request({ host, port, path: "/json/version", method: "GET" }, (res) => {
+        res.resume();
+        resolve10();
+      });
+      req.on("error", () => setTimeout(poll, 600));
+      req.setTimeout(1e3, () => {
+        req.destroy();
+        setTimeout(poll, 600);
+      });
+      req.end();
+    };
+    poll();
+  });
+}
+async function launchWindowsChrome(extensionPath, userDataDir, options = {}) {
+  const debugPort = options.debugPort ?? 9222;
+  const chromePath = findWindowsChrome();
+  if (!chromePath) throw new Error("Windows Chrome not found. Install Google Chrome for Windows.");
+  const nodePath = findWindowsNode();
+  if (!nodePath) throw new Error("Windows Node.js not found. Install Node.js for Windows.");
+  const winUserData = wslToWindowsPath(userDataDir);
+  const winExtPath = extensionPath ? wslToWindowsPath(extensionPath) : "";
+  const chromeProc = spawn(
+    chromePath,
+    [
+      `--remote-debugging-port=${debugPort}`,
+      `--user-data-dir=${winUserData}`,
+      ...winExtPath ? [`--disable-extensions-except=${winExtPath}`, `--load-extension=${winExtPath}`] : [],
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--disable-background-networking",
+      "--disable-sync",
+      "--disable-features=TranslateUI",
+      options.startMaximized ? "--start-maximized" : "--start-minimized"
+    ],
+    { stdio: "ignore", detached: true }
+  );
+  chromeProc.unref();
+  const windowsHost = getWindowsHostIP();
+  const { proc: relay, port: proxyPort } = await startRelay(nodePath, windowsHost, debugPort);
+  try {
+    await waitForChrome(windowsHost, proxyPort);
+    const browser = await chromium.connectOverCDP(`http://${windowsHost}:${proxyPort}`, { timeout: 5e3 });
+    return {
+      browser,
+      cleanup: async () => {
+        try {
+          await browser.close();
+        } catch {
+        }
+        relay.kill();
+      }
+    };
+  } catch (err) {
+    relay.kill();
+    throw err;
+  }
+}
+
+// src/browser/launch.ts
+function recordingViewport(config) {
+  const zoom = config.video.zoom && config.video.zoom > 0 ? config.video.zoom : 1;
+  return {
+    width: Math.round(config.video.width / zoom),
+    height: Math.round(config.video.height / zoom)
+  };
+}
+async function launchBrowserContext(config, userDataDir, recordVideo, storageStatePath) {
+  const extensionPath = config.browser?.extension;
+  const zoom = config.video.zoom && config.video.zoom > 0 ? config.video.zoom : 1;
+  const viewport = recordingViewport(config);
+  const scaleOpts = zoom === 1 ? {} : { deviceScaleFactor: zoom };
+  const videoOpts = recordVideo ? { recordVideo } : {};
+  const cspOpts = { bypassCSP: true };
+  const authOpts = storageStatePath ? { storageState: storageStatePath } : {};
+  let context;
+  let browser = null;
+  let chromeSession = null;
+  if (extensionPath) {
+    await mkdir2(userDataDir, { recursive: true });
+    const persistentArgs = [
+      `--disable-extensions-except=${extensionPath}`,
+      `--load-extension=${extensionPath}`,
+      "--window-position=-32000,-32000",
+      "--window-size=1,1"
+    ];
+    const useWindowsChrome = isWSL() && tryEnableWSLInterop();
+    if (useWindowsChrome) {
+      try {
+        chromeSession = await launchWindowsChrome(extensionPath, userDataDir, { viewport, ...scaleOpts, ...videoOpts });
+        const contexts = chromeSession.browser.contexts();
+        context = contexts[0] || await chromeSession.browser.newContext({
+          viewport,
+          ...scaleOpts,
+          ...videoOpts,
+          ...cspOpts,
+          acceptDownloads: true
+        });
+      } catch {
+        context = await chromium2.launchPersistentContext(userDataDir, {
+          headless: false,
+          args: persistentArgs,
+          viewport,
+          ...scaleOpts,
+          ...videoOpts,
+          ...cspOpts,
+          acceptDownloads: true
+        });
+      }
+    } else {
+      context = await chromium2.launchPersistentContext(userDataDir, {
+        headless: false,
+        args: persistentArgs,
+        viewport,
+        ...scaleOpts,
+        ...videoOpts,
+        ...cspOpts,
+        acceptDownloads: true
+      });
+    }
+  } else {
+    if (process.env.QP_HEADED === "1") {
+      const headedOpts = {
+        headless: false,
+        args: ["--disable-blink-features=AutomationControlled"],
+        ignoreDefaultArgs: ["--enable-automation"]
+      };
+      try {
+        browser = await chromium2.launch({ ...headedOpts, channel: "chrome" });
+      } catch {
+        browser = await chromium2.launch(headedOpts);
+      }
+    } else {
+      browser = await chromium2.launch({ headless: true });
+    }
+    context = await browser.newContext({
+      viewport,
+      ...scaleOpts,
+      ...videoOpts,
+      ...authOpts,
+      ...cspOpts,
+      acceptDownloads: true
+    });
+  }
+  await hideDevOverlays(context);
+  return { context, browser, chromeSession };
+}
+async function hideDevOverlays(context) {
+  await context.addInitScript(() => {
+    const css = "nextjs-portal,vite-error-overlay,vite-plugin-checker-error-overlay{display:none!important;pointer-events:none!important}";
+    const add = () => {
+      const style = document.createElement("style");
+      style.textContent = css;
+      document.head?.appendChild(style);
+    };
+    if (document.head) add();
+    else document.addEventListener("DOMContentLoaded", add, { once: true });
+  }).catch(() => {
+  });
+}
+async function launchSignInBrowser() {
+  const opts = {
+    headless: false,
+    args: ["--disable-blink-features=AutomationControlled"],
+    ignoreDefaultArgs: ["--enable-automation"]
+  };
+  try {
+    return await chromium2.launch({ ...opts, channel: "chrome" });
+  } catch {
+    return await chromium2.launch(opts);
+  }
+}
+async function cleanupBrowserSession(session) {
+  if (session.chromeSession) {
+    await session.chromeSession.cleanup();
+  } else {
+    await session.context.close();
+    if (session.browser) await session.browser.close();
+  }
+}
+
+// src/browser/auth-session.ts
+var pending = null;
+function pendingSignIn() {
+  return pending?.url ?? null;
+}
+async function openSignIn(url) {
+  await cancelSignIn();
+  const browser = await launchSignInBrowser();
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  pending = { browser, context, url };
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+  } catch {
+  }
+}
+function sameSite(a, b) {
+  if (a === b) return true;
+  const tail = (h) => h.split(".").slice(-2).join(".");
+  return a.includes(".") && b.includes(".") && tail(a) === tail(b);
+}
+function captureStartUrl(context, targetUrl) {
+  const targetHost = new URL(targetUrl).host;
+  const pages = context.pages();
+  for (let i = pages.length - 1; i >= 0; i--) {
+    const pageUrl = pages[i].url();
+    if (!pageUrl.startsWith("http")) continue;
+    if (sameSite(new URL(pageUrl).host, targetHost)) return pageUrl;
+  }
+  return void 0;
+}
+async function saveSignIn() {
+  if (!pending) throw new Error("No sign-in window is open. Call start_auth first.");
+  const { context, url } = pending;
+  try {
+    const startUrl = captureStartUrl(context, url);
+    const path = await saveAuthState(url, await context.storageState(), startUrl);
+    return { host: new URL(url).host, path, ...startUrl ? { startUrl } : {} };
+  } finally {
+    await cancelSignIn();
+  }
+}
+async function cancelSignIn() {
+  const open = pending;
+  pending = null;
+  await open?.browser.close().catch(() => {
+  });
+}
+
+// src/commands/edit-cmd.ts
+import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync4 } from "fs";
+import { join as join10 } from "path";
+import chalk7 from "chalk";
+
+// src/help.ts
+init_lib();
+import chalk from "chalk";
+
+// src/logo.ts
+import figlet from "figlet";
+import gradient from "gradient-string";
+var DEFAULT_LOGO_CONFIG = {
+  text: "QuickPeek",
+  font: "Slant",
+  horizontalLayout: "default",
+  gradientColors: ["#00ffff", "#00d4ff", "#a855f7", "#ec4899"],
+  suffix: " \u{1F440}"
+};
+function renderLogo(config = {}) {
+  const resolved = { ...DEFAULT_LOGO_CONFIG, ...config };
+  const ascii = figlet.textSync(resolved.text, {
+    font: resolved.font,
+    horizontalLayout: resolved.horizontalLayout
+  });
+  const colored = gradient(resolved.gradientColors)(ascii);
+  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
+}
+
+// src/help.ts
+init_config_loader();
+var cmd = chalk.cyan;
+var arg = chalk.green;
+var opt = chalk.magenta;
+var desc = chalk.white;
+var ex = chalk.dim;
+function showLogo() {
+  const logo = renderLogo();
+  console.log(logo);
+  console.log(chalk.dim(`  v${VERSION} - Auto-generate demo videos with AI`));
+  console.log(chalk.italic.dim("  Because Tutorial Videos are Overrated!\n"));
+}
+function formatUsageLines(status, tier) {
+  const lines = [];
+  lines.push(`Videos generated: ${status.usage_count}`);
+  if (tier !== "pro" && status.trial) {
+    const { uses_remaining, max_uses, days_remaining, is_expired } = status.trial;
+    const used = max_uses - uses_remaining;
+    lines.push(`Trial: ${used}/${max_uses} uses${is_expired ? " (expired)" : ` (${uses_remaining} remaining)`}`);
+    if (!is_expired && days_remaining > 0) {
+      lines.push(`Trial ends in ${days_remaining} day${days_remaining === 1 ? "" : "s"}`);
+    }
+  }
+  if (tier === "pro" && status.subscription) {
+    const end = status.subscription.current_period_end;
+    if (status.subscription.is_lifetime) {
+      lines.push("Lifetime access");
+    } else if (isCanceling(status)) {
+      const date = new Date(end).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+      lines.push(`Cancels: ${date}`);
+    } else if (end) {
+      const date = new Date(end).toLocaleDateString("en-US", { month: "short", day: "numeric", year: "numeric" });
+      lines.push(`Renews: ${date}`);
+    }
+  }
+  return lines;
+}
+
+// src/lib/browser-open.ts
+import { exec as exec2 } from "child_process";
+function editorBaseUrl() {
+  return (process.env.QUICKPEEK_API_BASE || "https://quickpeek.co").replace(/\/$/, "");
+}
+function openInBrowser(url) {
+  const isWSL2 = process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME);
+  const command = isWSL2 ? `cmd.exe /c start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  return new Promise((resolve10) => {
+    exec2(command, () => resolve10());
+  });
+}
+
+// src/lib/plan-validation.ts
+var INVALID_TARGETS = [
+  /\.png$/i,
+  /\.jpg$/i,
+  /\.gif$/i,
+  /\.webp$/i,
+  /\.svg$/i,
+  /sprite_sheet/i,
+  /downloaded/i
+];
+var ACTIONS_REQUIRING_TARGET = ["click", "type", "select", "check", "drag"];
+function isFilePath(value) {
+  if (!value) return false;
+  return /\.\w{2,5}$/.test(value) && (/[/\\]/.test(value) || /^[a-zA-Z]:/.test(value));
+}
+function isInvalidTarget(target) {
+  return INVALID_TARGETS.some((pattern) => pattern.test(target));
+}
+function validateStep(step) {
+  if (!step?.action) {
+    return "Missing action";
+  }
+  if (step.action === "navigate") {
+    if (!step.target) return "Navigate requires a URL target";
+    if (!step.target.startsWith("http://") && !step.target.startsWith("https://")) {
+      return "Navigate target must be a valid URL";
+    }
+  }
+  if (step.action === "media") {
+    if (!step.mediaFile && !isFilePath(step.value)) {
+      return "Media step requires a file (image or video)";
+    }
+  }
+  if (step.action === "upload") {
+    if (!step.mediaFile && !isFilePath(step.value)) {
+      return "Upload step requires a file";
+    }
+  }
+  if (ACTIONS_REQUIRING_TARGET.includes(step.action)) {
+    if (!step.target) return `${step.action} requires a target`;
+    if (isInvalidTarget(step.target)) return `Invalid target pattern: ${step.target}`;
+  }
+  return null;
+}
+
+// src/lib/plan-file.ts
+var MAX_HANDOFF_URL_CHARS = 32e3;
+function serializePlan(plan) {
+  return `${JSON.stringify(plan, null, 2)}
+`;
+}
+function parsePlanText(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    return { ok: false, error: `Not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ok: false, error: "A plan must be a JSON object." };
+  }
+  const candidate = raw;
+  if (typeof candidate.url !== "string" || !candidate.url.trim()) {
+    return { ok: false, error: "A plan needs a `url` to record." };
+  }
+  if (!Array.isArray(candidate.steps) || candidate.steps.length === 0) {
+    return { ok: false, error: "A plan needs at least one step." };
+  }
+  const steps = [];
+  for (const [index, step] of candidate.steps.entries()) {
+    if (!step || typeof step !== "object" || Array.isArray(step)) {
+      return { ok: false, error: `Step ${index + 1} is not an object.` };
+    }
+    const typed = step;
+    if (typeof typed.action !== "string" || !typed.action.trim()) {
+      return { ok: false, error: `Step ${index + 1} has no action.` };
+    }
+    const failure = validateStep(typed);
+    if (failure) return { ok: false, error: `Step ${index + 1}: ${failure}` };
+    steps.push({ ...typed, id: typed.id ?? index + 1 });
+  }
+  return {
+    ok: true,
+    plan: {
+      url: candidate.url,
+      title: candidate.title ?? "",
+      description: candidate.description ?? "",
+      ...candidate.lang ? { lang: candidate.lang } : {},
+      steps
+    }
+  };
+}
+function toBase64Url(text) {
+  const bytes = new TextEncoder().encode(text);
+  const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+  const base64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(text, "utf8").toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function encodePlan(plan) {
+  return toBase64Url(serializePlan(plan));
+}
+function planEditorUrl(baseUrl, plan) {
+  const url = `${baseUrl.replace(/\/$/, "")}/edit#plan=${encodePlan(plan)}`;
+  return url.length <= MAX_HANDOFF_URL_CHARS ? url : null;
+}
+
+// src/utils/ui.ts
+import { resolve as resolve4 } from "path";
+import { createInterface } from "readline";
 import chalk2 from "chalk";
 import ora from "ora";
 var INDENT = "   ";
@@ -2413,6 +3046,9 @@ var autoYes = false;
 function setAutoYes(value) {
   autoYes = value;
 }
+function isAutoYes() {
+  return autoYes;
+}
 function task(text) {
   return ora({ text, prefixText: INDENT, spinner: "dots" }).start();
 }
@@ -2446,7 +3082,7 @@ function promptInput(prompt2) {
 var _isWSL = process.platform === "linux" && process.env.WSL_DISTRO_NAME;
 function formatClickablePath(filePath) {
   const absolutePath = resolve4(filePath);
-  if (_isWSL) {
+  if (_isWSL || process.platform !== "win32") {
     return absolutePath;
   }
   let formatted = absolutePath;
@@ -2462,12 +3098,12 @@ function formatDuration(ms) {
   return `${mins}:${secs.toString().padStart(2, "0")}`;
 }
 
-// src/commands/phases/auth-phase.ts
+// src/commands/utils/record-helpers.ts
+import chalk6 from "chalk";
 init_lib();
-import chalk8 from "chalk";
 
 // src/plan.ts
-import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile6 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile3, writeFile as writeFile6 } from "fs/promises";
 import { join as join9 } from "path";
 import chalk5 from "chalk";
 import { chromium as chromium4 } from "playwright";
@@ -2478,19 +3114,11 @@ import { createInterface as createInterface2 } from "readline";
 import chalk4 from "chalk";
 
 // src/utils/browser-auth.ts
-init_SparkStripe_feature_gating();
 import { createServer } from "http";
 import { URL as URL2 } from "url";
 import chalk3 from "chalk";
+init_SparkStripe_feature_gating();
 var TIMEOUT_MS = 12e4;
-async function openBrowser(url) {
-  const { exec: exec2 } = await import("child_process");
-  const isWSL2 = process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME);
-  const command = isWSL2 ? `cmd.exe /c start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
-  return new Promise((resolve10) => {
-    exec2(command, () => resolve10());
-  });
-}
 async function browserLogin() {
   return new Promise((resolve10) => {
     let server;
@@ -2544,7 +3172,7 @@ async function browserLogin() {
       console.log(chalk3.dim(`  ${url}`));
       console.log();
       console.log(chalk3.dim("  Waiting for sign-in (press Ctrl+C to cancel)..."));
-      openBrowser(url);
+      void openInBrowser(url);
     });
     timer = setTimeout(() => {
       console.log();
@@ -2554,302 +3182,293 @@ async function browserLogin() {
   });
 }
 
-// src/ai/client.ts
-var lastRateLimitInfo = null;
-function getLastRateLimitInfo() {
-  return lastRateLimitInfo;
-}
-function prompt(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve10) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve10(answer.trim());
-    });
-  });
-}
-async function setupUserEmail() {
-  console.log();
-  console.log(chalk4.yellow("  \u2709 Account Setup"));
-  console.log(chalk4.dim("  \u2500".repeat(20)));
-  console.log();
-  console.log(chalk4.white("  Sign in with your Google account to track usage"));
-  console.log(chalk4.white("  and unlock Pro features."));
-  const browserEmail = await browserLogin();
-  if (browserEmail) {
-    console.log();
-    console.log(chalk4.green(`  \u2713 Signed in as ${browserEmail}`));
-    console.log();
-    return browserEmail;
-  }
-  console.log();
-  console.log(chalk4.dim("  Or enter your email manually:"));
-  const email = await prompt(chalk4.white("  Email: "));
-  if (!email) {
-    console.log();
-    console.log(chalk4.red("  No email provided. Exiting."));
-    process.exit(1);
-  }
-  if (!email.includes("@") || !email.includes(".")) {
-    console.log();
-    console.log(chalk4.yellow("  \u26A0 That doesn't look like a valid email address."));
-    const proceed = await prompt(chalk4.white("  Continue anyway? ") + chalk4.dim("[y/N] "));
-    if (proceed.toLowerCase() !== "y") {
-      process.exit(1);
-    }
-  }
-  console.log();
-  console.log(chalk4.green("  \u2713 Email registered"));
-  console.log();
-  return email;
-}
-async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "free") {
-  const result = process.env.SPARK_AI_KEY ? await callAI(systemPrompt, userPrompt, tier) : await callAIViaRelay(systemPrompt, userPrompt, userEmail ?? "", tier);
-  if (!result.success) {
-    await logError2("AI API", new Error(result.error));
-    if (result.isRateLimit) {
-      console.log();
-      console.log(chalk4.red("  \u26A0 Rate Limit Reached (after 3 retries)"));
-      console.log();
-      console.log(chalk4.dim("  Spark AI daily limit exceeded. You may have hit your quota."));
-      console.log(chalk4.dim("  Options:"));
-      if (result.retryAfterSeconds) {
-        const minutes = Math.ceil(result.retryAfterSeconds / 60);
-        console.log(chalk4.dim(`    \u2022 Wait ${minutes} minutes until quota resets`));
-      } else {
-        console.log(chalk4.dim("    \u2022 Wait until tomorrow (limits reset at midnight UTC)"));
-      }
-      console.log(chalk4.dim("    \u2022 Check your usage at: https://sparkbrain.app/dashboard"));
-      console.log(chalk4.dim("    \u2022 Upgrade to a higher tier for more requests"));
-      console.log();
-      process.exit(1);
-    }
-    if (result.isAuthError) {
-      console.log();
-      console.log(chalk4.red("  \u26A0 Authentication Error"));
-      console.log();
-      console.log(chalk4.dim(`  ${result.error}`));
-      console.log();
-      process.exit(1);
+// src/utils/logging.ts
+import { appendFile, mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname2, join as join8 } from "path";
+var LOG_FILE_NAME = "quickpeek.log";
+var logFileInitialized = false;
+var logFilePath = LOG_FILE_NAME;
+async function writeLogEntry(entry) {
+  try {
+    if (!logFileInitialized) {
+      await writeFile5(logFilePath, entry);
+      logFileInitialized = true;
+    } else {
+      await appendFile(logFilePath, entry);
     }
-    console.log();
-    console.log(chalk4.red("  \u26A0 AI Error"));
-    console.log();
-    const firstLine = result.error.split("\n")[0] ?? result.error;
-    console.log(chalk4.dim(`  ${firstLine.slice(0, 80)}`));
-    console.log();
-    process.exit(1);
+  } catch {
   }
-  lastRateLimitInfo = result.limits;
-  return result.content;
 }
+async function setLogFilePath(outputDir) {
+  logFilePath = join8(outputDir, LOG_FILE_NAME);
+  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
+${"=".repeat(60)}
 
-// src/browser/launch.ts
-import { mkdir as mkdir4 } from "fs/promises";
-import { chromium as chromium3 } from "playwright";
-
-// src/browser/wsl.ts
-import { execSync, spawn as spawn2 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
-import { request } from "http";
-import { chromium as chromium2 } from "playwright";
-function isWSL() {
-  if (process.platform !== "linux") return false;
+`;
   try {
-    const r = execSync("uname -r", { encoding: "utf-8" }).toLowerCase();
-    return r.includes("microsoft") || r.includes("wsl");
+    await mkdir5(dirname2(logFilePath), { recursive: true });
+    await writeFile5(logFilePath, header2);
+    logFileInitialized = true;
   } catch {
-    return false;
   }
 }
-function tryEnableWSLInterop() {
-  return existsSync6("/proc/sys/fs/binfmt_misc/WSLInterop");
+async function logInfo(context, message) {
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [${context}] ${message}
+`);
 }
-function wslToWindowsPath(wslPath) {
-  if (!wslPath) return wslPath;
-  const m = wslPath.match(/^\/mnt\/([a-z])\/(.*)/);
-  if (!m) return wslPath;
-  return `${m[1].toUpperCase()}:\\${m[2].replace(/\//g, "\\")}`;
+async function logDebug(context, message) {
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [${context}] ${message}
+`);
 }
-function findExe(whereExeQuery, ...hardcoded) {
-  for (const p of hardcoded) if (existsSync6(p)) return p;
-  try {
-    const line = execSync(`where.exe ${whereExeQuery}`, { encoding: "utf-8", timeout: 3e3 }).split("\n")[0]?.trim();
-    if (line) return line.replace(/^([A-Za-z]):\\/, (_, d) => `/mnt/${d.toLowerCase()}/`).replace(/\\/g, "/");
-  } catch {
+async function logError(context, error) {
+  let errorMsg;
+  if (error instanceof Error) {
+    errorMsg = `${error.message}
+${error.stack}`;
+  } else if (typeof error === "object" && error !== null) {
+    errorMsg = JSON.stringify(error, null, 2);
+  } else {
+    errorMsg = String(error);
   }
-  return null;
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] [${context}]
+${errorMsg}
+
+`);
 }
-var findWindowsChrome = () => findExe(
-  "chrome.exe",
-  "/mnt/c/Program Files/Google/Chrome/Application/chrome.exe",
-  "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"
-);
-var findWindowsNode = () => findExe("node.exe");
-function getWindowsHostIP() {
-  try {
-    const m = execSync("ip route show default", { encoding: "utf-8", timeout: 2e3 }).match(
-      /default via (\d+\.\d+\.\d+\.\d+)/
+async function logStep(stepNum, action, details) {
+  const detailsStr = Object.entries(details).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [STEP ${stepNum}] ${action} | ${detailsStr}
+`);
+}
+
+// src/ai/mcp-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var DelegatedGenerationError = class extends Error {
+  tool;
+  step;
+  /** The system instructions the call was about to send. */
+  system;
+  /** The user-side prompt. */
+  prompt;
+  constructor(tool, step, system, prompt2) {
+    super(
+      `Generation for "${tool}" (${step}) belongs to the calling model, not Groq. The tool should hand back this prompt and accept the result as a parameter.`
     );
-    if (m?.[1]) return m[1];
-  } catch {
-  }
-  try {
-    const m = readFileSync2("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
-    if (m?.[1]) return m[1];
-  } catch {
+    this.name = "DelegatedGenerationError";
+    this.tool = tool;
+    this.step = step;
+    this.system = system;
+    this.prompt = prompt2;
   }
-  return "127.0.0.1";
+};
+var mcpCall = new AsyncLocalStorage();
+function runInMcpTool(tool, fn, answers = {}) {
+  return mcpCall.run({ tool, answers, pending: [] }, fn);
 }
-function startRelay(nodePath, windowsHost, targetPort) {
-  const script = `var n=require('net'),s=n.createServer(function(c){var r=n.createConnection(${targetPort},'127.0.0.1');c.pipe(r);r.pipe(c);r.on('error',function(){c.destroy()});c.on('error',function(){r.destroy()});});s.listen(0,'${windowsHost}',function(){process.stdout.write('PORT:'+s.address().port+'\\n')});`;
-  return new Promise((resolve10, reject) => {
-    const proc = spawn2(nodePath, ["-e", script], { stdio: ["ignore", "pipe", "ignore"], detached: true });
-    const timer = setTimeout(() => reject(new Error("relay startup timed out")), 6e3);
-    let buf = "";
-    proc.stdout.on("data", (d) => {
-      buf += d.toString();
-      const m = buf.match(/PORT:(\d+)/);
-      if (m) {
-        clearTimeout(timer);
-        resolve10({ proc, port: +m[1] });
-      }
-    });
-    proc.on("error", (e) => {
-      clearTimeout(timer);
-      reject(e);
-    });
-  });
+function currentMcpTool() {
+  return mcpCall.getStore()?.tool ?? null;
 }
-function waitForChrome(host, port) {
-  return new Promise((resolve10, reject) => {
-    const deadline = Date.now() + 2e4;
-    const poll = () => {
-      if (Date.now() > deadline) {
-        reject(new Error("Chrome debug port did not open within 20 s"));
-        return;
-      }
-      const req = request({ host, port, path: "/json/version", method: "GET" }, (res) => {
-        res.resume();
-        resolve10();
-      });
-      req.on("error", () => setTimeout(poll, 600));
-      req.setTimeout(1e3, () => {
-        req.destroy();
-        setTimeout(poll, 600);
-      });
-      req.end();
-    };
-    poll();
+function suppliedAnswer(step) {
+  return mcpCall.getStore()?.answers?.[step];
+}
+function recordDelegation(e) {
+  const store = mcpCall.getStore();
+  if (store && !store.pending.some((p) => p.step === e.step)) store.pending.push(e);
+}
+function pendingDelegations() {
+  return mcpCall.getStore()?.pending ?? [];
+}
+
+// src/ai/client.ts
+var lastRateLimitInfo = null;
+function wrap(text, width) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let current = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      if (current && current.length + word.length + 1 > width) {
+        lines.push(current);
+        current = word;
+      } else {
+        current = current ? `${current} ${word}` : word;
+      }
+    }
+    lines.push(current);
+  }
+  return lines.filter((l) => l.length > 0);
+}
+function diagnose(status, host) {
+  const where = host ?? "the AI service";
+  if (status === void 0) return `Could not reach ${where}. Check your network, then retry.`;
+  if (status === 401 || status === 403) return `${where} rejected the credentials. Run qp login and retry.`;
+  if (status === 413) return `The prompt was too large for ${where}. Shorten the script or the page.`;
+  if (status === 429) return `${where} is rate limiting. Wait for the quota to reset, then retry.`;
+  if (status === 502 || status === 503 || status === 504) {
+    return `${where} could not reach the AI backend (upstream outage). Retry in a few minutes.`;
+  }
+  if (status >= 500) return `${where} failed internally. Retry in a few minutes; if it persists, report this.`;
+  return `${where} rejected the request. See the body above.`;
+}
+function getLastRateLimitInfo() {
+  return lastRateLimitInfo;
+}
+function prompt(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve10) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve10(answer.trim());
+    });
   });
 }
-async function launchWindowsChrome(extensionPath, userDataDir, options = {}) {
-  const debugPort = options.debugPort ?? 9222;
-  const chromePath = findWindowsChrome();
-  if (!chromePath) throw new Error("Windows Chrome not found. Install Google Chrome for Windows.");
-  const nodePath = findWindowsNode();
-  if (!nodePath) throw new Error("Windows Node.js not found. Install Node.js for Windows.");
-  const winUserData = wslToWindowsPath(userDataDir);
-  const winExtPath = extensionPath ? wslToWindowsPath(extensionPath) : "";
-  const chromeProc = spawn2(
-    chromePath,
-    [
-      `--remote-debugging-port=${debugPort}`,
-      `--user-data-dir=${winUserData}`,
-      ...winExtPath ? [`--disable-extensions-except=${winExtPath}`, `--load-extension=${winExtPath}`] : [],
-      "--no-first-run",
-      "--no-default-browser-check",
-      "--disable-background-networking",
-      "--disable-sync",
-      "--disable-features=TranslateUI",
-      options.startMaximized ? "--start-maximized" : "--start-minimized"
-    ],
-    { stdio: "ignore", detached: true }
-  );
-  chromeProc.unref();
-  const windowsHost = getWindowsHostIP();
-  const { proc: relay, port: proxyPort } = await startRelay(nodePath, windowsHost, debugPort);
-  try {
-    await waitForChrome(windowsHost, proxyPort);
-    const browser = await chromium2.connectOverCDP(`http://${windowsHost}:${proxyPort}`, { timeout: 5e3 });
-    return {
-      browser,
-      cleanup: async () => {
-        try {
-          await browser.close();
-        } catch {
-        }
-        relay.kill();
-      }
-    };
-  } catch (err) {
-    relay.kill();
-    throw err;
+async function setupUserEmail() {
+  console.log();
+  console.log(chalk4.yellow("  \u2709 Account Setup"));
+  console.log(chalk4.dim("  \u2500".repeat(20)));
+  console.log();
+  console.log(chalk4.white("  Sign in with your Google account to track usage"));
+  console.log(chalk4.white("  and unlock Pro features."));
+  const browserEmail = await browserLogin();
+  if (browserEmail) {
+    console.log();
+    console.log(chalk4.green(`  \u2713 Signed in as ${browserEmail}`));
+    console.log();
+    return browserEmail;
+  }
+  console.log();
+  console.log(chalk4.dim("  Or enter your email manually:"));
+  const email = await prompt(chalk4.white("  Email: "));
+  if (!email) {
+    console.log();
+    console.log(chalk4.red("  No email provided. Exiting."));
+    process.exit(1);
+  }
+  if (!email.includes("@") || !email.includes(".")) {
+    console.log();
+    console.log(chalk4.yellow("  \u26A0 That doesn't look like a valid email address."));
+    const proceed = await prompt(chalk4.white("  Continue anyway? ") + chalk4.dim("[y/N] "));
+    if (proceed.toLowerCase() !== "y") {
+      process.exit(1);
+    }
   }
+  console.log();
+  console.log(chalk4.green("  \u2713 Email registered"));
+  console.log();
+  return email;
 }
-
-// src/browser/launch.ts
-async function launchBrowserContext(config, userDataDir, recordVideo, storageStatePath) {
-  const extensionPath = config.browser?.extension;
-  const viewport = { width: config.video.width, height: config.video.height };
-  const videoOpts = recordVideo ? { recordVideo } : {};
-  const authOpts = storageStatePath ? { storageState: storageStatePath } : {};
-  let context;
-  let browser = null;
-  let chromeSession = null;
-  if (extensionPath) {
-    await mkdir4(userDataDir, { recursive: true });
-    const persistentArgs = [
-      `--disable-extensions-except=${extensionPath}`,
-      `--load-extension=${extensionPath}`,
-      "--window-position=-32000,-32000",
-      "--window-size=1,1"
-    ];
-    const useWindowsChrome = isWSL() && tryEnableWSLInterop();
-    if (useWindowsChrome) {
-      try {
-        chromeSession = await launchWindowsChrome(extensionPath, userDataDir, { viewport, ...videoOpts });
-        const contexts = chromeSession.browser.contexts();
-        context = contexts[0] || await chromeSession.browser.newContext({ viewport, ...videoOpts, acceptDownloads: true });
-      } catch {
-        context = await chromium3.launchPersistentContext(userDataDir, {
-          headless: false,
-          args: persistentArgs,
-          viewport,
-          ...videoOpts,
-          acceptDownloads: true
-        });
+async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "free", step = "plan") {
+  const mcpTool = currentMcpTool();
+  if (mcpTool) {
+    const answered = suppliedAnswer(step);
+    if (typeof answered === "string") return answered;
+    const refusal = new DelegatedGenerationError(mcpTool, step, systemPrompt, userPrompt);
+    recordDelegation(refusal);
+    throw refusal;
+  }
+  const onRetry = ({ attempt, status, delayMs, host }) => {
+    console.log(
+      chalk4.dim(
+        `
+  ${host} returned ${status}; retrying in ${Math.round(delayMs / 1e3)}s (attempt ${attempt + 1} of 3)`
+      )
+    );
+  };
+  const chatOpts = { onRetry, backoffMs: CLI_BACKOFF_MS };
+  const result = process.env.SPARK_AI_KEY ? await callAI(systemPrompt, userPrompt, tier, chatOpts) : await callAIViaRelay(systemPrompt, userPrompt, userEmail ?? "", tier, chatOpts);
+  if (!result.success) {
+    await logError2("AI API", new Error(result.detail ? `${result.error}
+Body: ${result.detail}` : result.error));
+    if (result.isRateLimit) {
+      console.log();
+      console.log(chalk4.red("  \u26A0 Rate Limit Reached (after 3 retries)"));
+      console.log();
+      console.log(chalk4.dim(`  ${result.error}`));
+      console.log(chalk4.dim("  Options:"));
+      if (result.retryAfterSeconds) {
+        const minutes = Math.ceil(result.retryAfterSeconds / 60);
+        console.log(chalk4.dim(`    \u2022 Wait ${minutes} minutes until quota resets`));
+      } else {
+        console.log(chalk4.dim("    \u2022 Wait until tomorrow (limits reset at midnight UTC)"));
       }
-    } else {
-      context = await chromium3.launchPersistentContext(userDataDir, {
-        headless: false,
-        args: persistentArgs,
-        viewport,
-        ...videoOpts,
-        acceptDownloads: true
-      });
+      console.log(chalk4.dim("    \u2022 Check your usage at: https://sparkbrain.app/dashboard"));
+      console.log(chalk4.dim("    \u2022 Upgrade to a higher tier for more requests"));
+      console.log();
+      process.exit(1);
     }
-  } else {
-    browser = await chromium3.launch({ headless: true });
-    context = await browser.newContext({ viewport, ...videoOpts, ...authOpts, acceptDownloads: true });
+    if (result.isAuthError) {
+      console.log();
+      console.log(chalk4.red(`  \u26A0 Authentication Error${result.status ? ` (HTTP ${result.status})` : ""}`));
+      console.log();
+      for (const line of wrap(result.error, 76)) {
+        console.log(chalk4.dim(`  ${line}`));
+      }
+      console.log();
+      console.log(chalk4.dim(`  ${diagnose(result.status, result.host)}`));
+      console.log();
+      process.exit(1);
+    }
+    console.log();
+    console.log(chalk4.red(`  \u26A0 AI Error${result.status ? ` (HTTP ${result.status})` : ""}`));
+    console.log();
+    for (const line of wrap(result.error, 76)) {
+      console.log(chalk4.dim(`  ${line}`));
+    }
+    if (result.detail && !result.error.includes(result.detail)) {
+      console.log();
+      for (const line of wrap(result.detail, 76).slice(0, 6)) {
+        console.log(chalk4.dim(`  ${line}`));
+      }
+    }
+    console.log();
+    console.log(chalk4.dim(`  ${diagnose(result.status, result.host)}`));
+    console.log(chalk4.dim(`  Full response body: ${logFilePath}`));
+    console.log();
+    process.exit(1);
   }
-  return { context, browser, chromeSession };
+  lastRateLimitInfo = result.limits;
+  return result.content;
 }
-async function cleanupBrowserSession(session) {
-  if (session.chromeSession) {
-    await session.chromeSession.cleanup();
-  } else {
-    await session.context.close();
-    if (session.browser) await session.browser.close();
+
+// src/ai/json-plan.ts
+init_lib();
+init_utils();
+var JSON_FIX_SYSTEM_PROMPT = "You fix malformed JSON. Return ONLY valid JSON, no explanation.";
+var PLAN_SHAPE = `The JSON should have: url, title, description, steps array.
+Each step has: id (number), action, caption, and optionally target, value.`;
+var jsonFixUserPrompt = (content, shape) => `Fix this malformed JSON. Return ONLY valid JSON, no explanation.
+${shape}
+
+Malformed content:
+${content}`;
+var noopTask2 = () => ({ succeed: () => {
+}, fail: () => {
+} });
+async function parseAIJsonWithRepair(content, opts) {
+  const { logError: logError2, userEmail, tier = "free", shape = PLAN_SHAPE, context = "JSON Fix" } = opts;
+  const direct = parseAIJson(content);
+  if (direct) return direct.value;
+  const makeTask = opts.task ?? noopTask2;
+  const fixTask = makeTask("Fixing malformed JSON");
+  try {
+    const fixed = await callGroq(JSON_FIX_SYSTEM_PROMPT, jsonFixUserPrompt(content, shape), logError2, userEmail, tier);
+    const repaired = parseAIJson(fixed);
+    if (!repaired) throw new Error("No usable JSON in fix");
+    fixTask.succeed("JSON fixed by AI");
+    return repaired.value;
+  } catch (err) {
+    await logError2(context, err);
+    fixTask.fail("Could not fix JSON");
+    throw new Error(`Malformed JSON: ${getErrorMessage(err)}`);
   }
 }
 
 // src/plan.ts
 init_lib();
+init_json_repair();
 async function crawlExtension(url, extensionPath, workDir, task2) {
   const browserTask = task2("Launching browser with extension");
   const userDataDir = join9(workDir, ".browser-data");
-  await mkdir5(userDataDir, { recursive: true });
+  await mkdir6(userDataDir, { recursive: true });
   let context;
   let chromeSession = null;
   const useWindowsChrome = isWSL() && tryEnableWSLInterop();
@@ -2934,7 +3553,7 @@ async function crawlExtension(url, extensionPath, workDir, task2) {
     else if (el.type === "select" || el.type === "select-one") action = "select";
     else if (el.type === "checkbox") action = "check";
     else if (["text", "email", "password", "number", "search", "url", "tel"].includes(el.type)) action = "type";
-    const selector = el.id ? `#${el.id}` : el.name ? `[name="${el.name}"]` : `text="${el.text}"`;
+    const selector = el.id ? idSelector(el.id) : el.name ? `[name="${el.name}"]` : `text="${el.text}"`;
     return {
       type: el.type === "button" || el.type === "link" ? el.type : "input",
       text: el.text,
@@ -2946,43 +3565,19 @@ async function crawlExtension(url, extensionPath, workDir, task2) {
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
   return { title, elements };
 }
-var JSON_FIX_SYSTEM_PROMPT = "You fix malformed JSON. Return ONLY valid JSON, no explanation.";
-var jsonFixUserPrompt = (content) => `Fix this malformed JSON plan. Return ONLY valid JSON, no explanation.
-The JSON should have: url, title, description, steps array.
-Each step has: id (number), action, caption, and optionally target, value.
-
-Malformed content:
-${content}`;
 async function parsePlanJson(content, task2, logError2, userEmail, tier = "free") {
-  try {
-    return JSON.parse(content);
-  } catch {
-    const fixTask = task2("Fixing malformed JSON");
-    try {
-      const fixed = await callGroq(JSON_FIX_SYSTEM_PROMPT, jsonFixUserPrompt(content), logError2, userEmail, tier);
-      const jsonMatch = fixed.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) throw new Error("No JSON in fix");
-      const plan = JSON.parse(jsonMatch[0]);
-      fixTask.succeed("JSON fixed by AI");
-      return plan;
-    } catch (err) {
-      await logError2("JSON Fix", err);
-      fixTask.fail("Could not fix JSON");
-      throw new Error(`Malformed JSON: ${getErrorMessage(err)}`);
-    }
-  }
+  return parseAIJsonWithRepair(content, { logError: logError2, task: task2, userEmail, tier });
 }
-async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError2, userEmail, extensionPath, workDir, tier = "free") {
-  const { title, elements } = extensionPath && workDir ? await crawlExtension(url, extensionPath, workDir, task2) : await crawlPage(url, task2, findAuthState(url));
+async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError2, userEmail, extensionPath, workDir, tier = "free", viewport) {
+  const { title, elements, scrollable } = extensionPath && workDir ? { ...await crawlExtension(url, extensionPath, workDir, task2), scrollable: void 0 } : await crawlPage(url, task2, findAuthState(url), viewport);
   const aiTask = task2("Generating plan with AI");
   const langName = getLanguageName(lang);
   const systemPrompt = buildSystemPrompt(maxSteps);
-  const userPrompt = buildUserPrompt(url, title, elements, langName, description, maxSteps);
+  const userPrompt = buildUserPrompt(url, title, elements, langName, description, maxSteps, scrollable);
   try {
-    const content = await callGroq(systemPrompt, userPrompt, logError2, userEmail, tier);
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) throw new Error("No JSON found in response");
-    const plan = await parsePlanJson(jsonMatch[0], task2, logError2, userEmail, tier);
+    const content = await callGroq(systemPrompt, userPrompt, logError2, userEmail, tier, "plan");
+    const plan = await parsePlanJson(content, task2, logError2, userEmail, tier);
+    if (!Array.isArray(plan.steps)) throw new Error("AI response has no steps array");
     if (lang !== void 0) plan.lang = lang;
     plan.steps = plan.steps.map(({ duration, ...s }, i) => ({
       ...s,
@@ -3006,100 +3601,41 @@ async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier =
   }
   const renumberTask = task2("Validating plan structure");
   const originalCount = plan.steps.length;
-  const INVALID_TARGETS = [/\.png$/i, /\.jpg$/i, /\.gif$/i, /\.webp$/i, /\.svg$/i, /sprite_sheet/i, /downloaded/i];
-  const isValidStep = (s) => {
-    if (!s?.action) return false;
-    if (s.action === "navigate") {
-      if (!s.target) return false;
-      if (!s.target.startsWith("http://") && !s.target.startsWith("https://")) return false;
-    }
-    if (["click", "type", "select", "check", "upload", "drag"].includes(s.action)) {
-      if (!s.target) return false;
-      if (INVALID_TARGETS.some((pattern) => pattern.test(s.target))) return false;
-    }
-    if (s.action === "upload") {
-      if (!s.target?.includes("file") && !s.target?.includes("input")) return false;
-    }
-    return true;
-  };
-  plan.steps = plan.steps.filter(isValidStep).map(({ duration, ...step }, i) => ({
-    ...step,
-    id: i + 1,
-    // Ensure upload steps have a value placeholder
-    ...step.action === "upload" && !step.value ? { value: "[file]" } : {}
-  }));
-  if (plan.steps.length === 0) {
-    renumberTask.fail("No valid steps");
-    throw new Error("Plan has no valid steps");
-  }
-  await writeFile6(planPath, JSON.stringify(plan, null, 2));
-  const removed = originalCount - plan.steps.length;
-  renumberTask.succeed(
-    removed > 0 ? `${plan.steps.length} steps (${removed} removed)` : `${plan.steps.length} steps validated`
-  );
-  return plan;
-}
-
-// src/commands/phases/auth-phase.ts
-init_config_loader();
-
-// src/commands/utils/auth-helpers.ts
-init_lib();
-import chalk6 from "chalk";
-async function handleRegistrationGate() {
-  console.log();
-  console.log(chalk6.yellow("  \u{1F389} You've made 5 free videos!"));
-  console.log(chalk6.white("     Sign in to continue creating videos."));
-  console.log();
-  console.log(chalk6.dim("  Benefits of signing in:"));
-  console.log(chalk6.dim("    \u2022 20 more videos per month"));
-  console.log(chalk6.dim("    \u2022 Keep your video history"));
-  console.log(chalk6.dim("    \u2022 Upgrade to Pro anytime"));
-  let email = await browserLogin();
-  if (!email) {
-    console.log();
-    email = await promptInput("Email: ");
-  }
-  if (!email || !email.includes("@")) {
-    console.log(chalk6.red("  Invalid email. Run qp again to try again."));
-    return null;
-  }
-  const registerTask = task("Sending verification email");
-  const result = await registerFreeUser(email);
-  if (!result.success) {
-    registerTask.fail(result.error || "Registration failed");
-    return null;
-  }
-  if (result.alreadyVerified) {
-    registerTask.succeed("Already verified!");
-    return { email, verified: true };
-  }
-  registerTask.succeed("Check your email!");
-  console.log();
-  console.log(chalk6.cyan("  \u{1F4E7} Verification email sent to:"));
-  console.log(chalk6.white(`     ${email}`));
-  console.log();
-  console.log(chalk6.dim("  Click the link in the email, then press Enter to continue..."));
-  await promptInput("");
-  const verifyTask = task("Checking verification");
-  const verified = await isVerified(email);
-  if (verified) {
-    verifyTask.succeed("Email verified!");
-    return { email, verified: true };
+  const INVALID_TARGETS2 = [/\.png$/i, /\.jpg$/i, /\.gif$/i, /\.webp$/i, /\.svg$/i, /sprite_sheet/i, /downloaded/i];
+  const isValidStep = (s) => {
+    if (!s?.action) return false;
+    if (s.action === "navigate") {
+      if (!s.target) return false;
+      if (!s.target.startsWith("http://") && !s.target.startsWith("https://")) return false;
+    }
+    if (["click", "type", "select", "check", "upload", "drag"].includes(s.action)) {
+      if (!s.target) return false;
+      if (INVALID_TARGETS2.some((pattern) => pattern.test(s.target))) return false;
+    }
+    if (s.action === "upload") {
+      if (!s.target?.includes("file") && !s.target?.includes("input")) return false;
+    }
+    return true;
+  };
+  plan.steps = plan.steps.filter(isValidStep).map(({ duration, ...step }, i) => ({
+    ...step,
+    id: i + 1,
+    // Ensure upload steps have a value placeholder
+    ...step.action === "upload" && !step.value ? { value: "[file]" } : {}
+  }));
+  if (plan.steps.length === 0) {
+    renumberTask.fail("No valid steps");
+    throw new Error("Plan has no valid steps");
   }
-  verifyTask.fail("Not verified yet");
-  console.log();
-  console.log(chalk6.yellow("  Email not verified. Check your inbox and spam folder."));
-  console.log(chalk6.dim("  Run qp again after clicking the verification link."));
-  console.log();
-  console.log(chalk6.cyan(`  Or register/upgrade at: ${getUpgradeUrl(email)}`));
-  console.log();
-  return { email, verified: false };
+  await writeFile6(planPath, JSON.stringify(plan, null, 2));
+  const removed = originalCount - plan.steps.length;
+  renumberTask.succeed(
+    removed > 0 ? `${plan.steps.length} steps (${removed} removed)` : `${plan.steps.length} steps validated`
+  );
+  return plan;
 }
 
 // src/commands/utils/record-helpers.ts
-import chalk7 from "chalk";
-init_lib();
 init_config_loader();
 init_utils();
 var FREE_VIDEO_LIMIT = 5;
@@ -3124,41 +3660,41 @@ function displayRateLimitInfo() {
   const percentage = Math.round(limits.used / limits.limit * 100);
   if (percentage >= 90) {
     console.log();
-    console.log(chalk7.yellow(`  \u26A0 ${remaining} requests remaining (${limits.tier} tier)`));
+    console.log(chalk6.yellow(`  \u26A0 ${remaining} requests remaining (${limits.tier} tier)`));
     if (limits.tier === "free") {
-      console.log(chalk7.dim(`    Upgrade: ${getUpgradeUrl()}`));
+      console.log(chalk6.dim(`    Upgrade: ${getUpgradeUrl()}`));
     }
   } else if (percentage >= 50) {
-    console.log(chalk7.dim(`  ${remaining}/${limits.limit} requests remaining`));
+    console.log(chalk6.dim(`  ${remaining}/${limits.limit} requests remaining`));
   }
 }
 async function displayUsageStatus(userEmail, userTier, _localVideoCount = 0) {
   const tier = userTier === "pro" ? "pro" : "free";
-  const tierLabel = tier === "pro" ? chalk7.green("Pro") : "Free";
-  console.log(chalk7.cyan(`    \u2714 ${tierLabel} plan`));
-  console.log(chalk7.dim(`      ${userEmail}`));
+  const tierLabel = tier === "pro" ? chalk6.green("Pro") : "Free";
+  console.log(chalk6.cyan(`    \u2714 ${tierLabel} plan`));
+  console.log(chalk6.dim(`      ${userEmail}`));
   if (userEmail && userEmail !== "anonymous") {
     try {
       const status = await getStatusCached(userEmail);
       for (const line of formatUsageLines(status, tier)) {
-        console.log(chalk7.dim(`      ${line}`));
+        console.log(chalk6.dim(`      ${line}`));
       }
     } catch {
     }
   }
   if (userTier === "free") {
     const upgradeUrl = getUpgradeUrl(userEmail !== "anonymous" ? userEmail : void 0);
-    console.log(chalk7.dim(`      Upgrade: ${upgradeUrl}`));
+    console.log(chalk6.dim(`      Upgrade: ${upgradeUrl}`));
   }
 }
 function displayPlanSummary(plan) {
   console.log();
-  console.log(chalk7.dim(`  ${plan.title || "Untitled"}`));
-  console.log(chalk7.dim(`  ${plan.steps?.length || 0} steps`));
+  console.log(chalk6.dim(`  ${plan.title || "Untitled"}`));
+  console.log(chalk6.dim(`  ${plan.steps?.length || 0} steps`));
   for (const step of plan.steps || []) {
     const text = step.caption || step.action || "";
     const caption = text.length > 50 ? `${text.slice(0, 47)}...` : text;
-    console.log(chalk7.dim(`    ${step.id}. ${caption}`));
+    console.log(chalk6.dim(`    ${step.id}. ${caption}`));
   }
 }
 function getOutputDirFromUrl(url) {
@@ -3205,6 +3741,86 @@ function getOutputDirFromUrl(url) {
   }
 }
 
+// src/commands/edit-cmd.ts
+var PLAN_FILE = /^plan-([a-z]{2}(?:-[A-Z]{2})?)\.json$/;
+function findPlanFile(dir, lang) {
+  if (lang) {
+    const exact = join10(dir, `plan-${lang}.json`);
+    return existsSync7(exact) ? exact : null;
+  }
+  if (!existsSync7(dir)) return null;
+  const plans = readdirSync(dir).filter((f) => PLAN_FILE.test(f));
+  const preferred = plans.find((f) => f === "plan-en.json") ?? plans[0];
+  return preferred ? join10(dir, preferred) : null;
+}
+
+// src/commands/record-cmd.ts
+import { existsSync as existsSync18 } from "fs";
+import { mkdir as mkdir9 } from "fs/promises";
+import { isAbsolute as isAbsolute5, join as join21, resolve as resolve9 } from "path";
+import chalk15 from "chalk";
+init_lib();
+init_config_loader();
+
+// src/commands/phases/auth-phase.ts
+init_lib();
+import chalk9 from "chalk";
+init_config_loader();
+
+// src/commands/utils/auth-helpers.ts
+init_lib();
+import chalk8 from "chalk";
+async function handleRegistrationGate() {
+  console.log();
+  console.log(chalk8.yellow("  \u{1F389} You've made 5 free videos!"));
+  console.log(chalk8.white("     Sign in to continue creating videos."));
+  console.log();
+  console.log(chalk8.dim("  Benefits of signing in:"));
+  console.log(chalk8.dim("    \u2022 20 more videos per month"));
+  console.log(chalk8.dim("    \u2022 Keep your video history"));
+  console.log(chalk8.dim("    \u2022 Upgrade to Pro anytime"));
+  let email = await browserLogin();
+  if (!email) {
+    console.log();
+    email = await promptInput("Email: ");
+  }
+  if (!email || !email.includes("@")) {
+    console.log(chalk8.red("  Invalid email. Run qp again to try again."));
+    return null;
+  }
+  const registerTask = task("Sending verification email");
+  const result = await registerFreeUser(email);
+  if (!result.success) {
+    registerTask.fail(result.error || "Registration failed");
+    return null;
+  }
+  if (result.alreadyVerified) {
+    registerTask.succeed("Already verified!");
+    return { email, verified: true };
+  }
+  registerTask.succeed("Check your email!");
+  console.log();
+  console.log(chalk8.cyan("  \u{1F4E7} Verification email sent to:"));
+  console.log(chalk8.white(`     ${email}`));
+  console.log();
+  console.log(chalk8.dim("  Click the link in the email, then press Enter to continue..."));
+  await promptInput("");
+  const verifyTask = task("Checking verification");
+  const verified = await isVerified(email);
+  if (verified) {
+    verifyTask.succeed("Email verified!");
+    return { email, verified: true };
+  }
+  verifyTask.fail("Not verified yet");
+  console.log();
+  console.log(chalk8.yellow("  Email not verified. Check your inbox and spam folder."));
+  console.log(chalk8.dim("  Run qp again after clicking the verification link."));
+  console.log();
+  console.log(chalk8.cyan(`  Or register/upgrade at: ${getUpgradeUrl(email)}`));
+  console.log();
+  return { email, verified: false };
+}
+
 // src/commands/phases/auth-phase.ts
 async function runAuthPhase(input) {
   let { userEmail, userTier, localVideoCount } = input;
@@ -3228,7 +3844,7 @@ async function runAuthPhase(input) {
     } else {
       verifyTask.fail("Email not verified");
       console.log();
-      console.log(chalk8.yellow("  Check your inbox for the verification email."));
+      console.log(chalk9.yellow("  Check your inbox for the verification email."));
       console.log();
       const input2 = await promptInput(`New email or Enter to retry (${userEmail}): `);
       if (input2.toLowerCase() === "exit") {
@@ -3253,8 +3869,8 @@ async function runAuthPhase(input) {
           registerTask.succeed("Check your email!");
           await saveUserData({ email: newEmail, verified: false });
           console.log();
-          console.log(chalk8.cyan(`  \u{1F4E7} Verification sent to: ${newEmail}`));
-          console.log(chalk8.dim("  Click the link in the email, then run qp again."));
+          console.log(chalk9.cyan(`  \u{1F4E7} Verification sent to: ${newEmail}`));
+          console.log(chalk9.dim("  Click the link in the email, then run qp again."));
           console.log();
           gracefulExit();
           return null;
@@ -3270,7 +3886,7 @@ async function runAuthPhase(input) {
         } else {
           recheckTask.fail("Still not verified");
           console.log();
-          console.log(chalk8.cyan(`  Register/upgrade at: ${getUpgradeUrl(userEmail)}`));
+          console.log(chalk9.cyan(`  Register/upgrade at: ${getUpgradeUrl(userEmail)}`));
           console.log();
           gracefulExit();
           return null;
@@ -3297,8 +3913,8 @@ async function runAuthPhase(input) {
   } else {
     const remaining = FREE_VIDEO_LIMIT - localVideoCount;
     console.log();
-    console.log(chalk8.cyan(`  \u{1F3AC} Video ${localVideoCount + 1}/${FREE_VIDEO_LIMIT} free`));
-    console.log(chalk8.dim(`     ${remaining - 1} more after this \u2022 Sign up for unlimited`));
+    console.log(chalk9.cyan(`  \u{1F3AC} Video ${localVideoCount + 1}/${FREE_VIDEO_LIMIT} free`));
+    console.log(chalk9.dim(`     ${remaining - 1} more after this \u2022 Sign up for unlimited`));
     userEmail = await setupUserEmail();
     let registeredVerified = false;
     try {
@@ -3317,18 +3933,18 @@ async function runAuthPhase(input) {
 }
 
 // src/commands/phases/plan-phase.ts
-import { existsSync as existsSync7, readdirSync } from "fs";
+import { existsSync as existsSync8, readdirSync as readdirSync2 } from "fs";
 import { readFile as readFile4 } from "fs/promises";
-import { basename, join as join10 } from "path";
-import chalk9 from "chalk";
+import { basename, join as join11 } from "path";
+import chalk10 from "chalk";
 
 // src/ai/fix.ts
 init_lib();
 async function callGroqAndFinalize(systemPrompt, userMessage, plan, logError2, userEmail, tier = "free") {
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const jsonMatch = content.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON in AI response");
-  return finalizePlan(JSON.parse(jsonMatch[0]), plan);
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "fix");
+  const result = await parseAIJsonWithRepair(content, { logError: logError2, userEmail, tier, context: "Plan Fix" });
+  if (!Array.isArray(result.steps)) throw new Error("AI response has no steps array");
+  return finalizePlan(result, plan);
 }
 function finalizePlan(result, original) {
   result.url = original.url;
@@ -3452,10 +4068,15 @@ async function translatePlan(plan, targetLang, logError2, userEmail, tier = "fre
 ${JSON.stringify(toTranslate)}
 
 Return ONLY JSON: {"description": "...", "captions": ["...", ...]}`;
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const jsonMatch = content.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON in translation response");
-  const translated = JSON.parse(jsonMatch[0]);
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "fix");
+  const translated = await parseAIJsonWithRepair(content, {
+    logError: logError2,
+    userEmail,
+    tier,
+    shape: "The JSON should have: description (string), captions (array of strings).",
+    context: "Translate Plan"
+  });
+  if (!Array.isArray(translated.captions)) throw new Error("Translation response has no captions array");
   const translatedPlan = JSON.parse(JSON.stringify(plan));
   translatedPlan.title = plan.title;
   translatedPlan.description = translated.description || plan.description;
@@ -3473,12 +4094,22 @@ Return ONLY JSON: {"description": "...", "captions": ["...", ...]}`;
 init_config_loader();
 var INDENT3 = "   ";
 async function runPlanPhase(params) {
-  const { url, config, userEmail, description, planPath, legacyPlanPath, targetLang, userTier = "free" } = params;
+  const {
+    url,
+    config,
+    userEmail,
+    description,
+    planPath,
+    legacyPlanPath,
+    targetLang,
+    userTier = "free",
+    fresh = false
+  } = params;
   const maxSteps = config.plan?.maxSteps ?? 8;
   const extensionPath = config.browser?.extension;
   let existingPlan = null;
   let existingPlanPath = null;
-  if (existsSync7(planPath)) {
+  if (existsSync8(planPath)) {
     try {
       const parsed = JSON.parse(await readFile4(planPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
@@ -3490,10 +4121,10 @@ async function runPlanPhase(params) {
   }
   if (!existingPlan) {
     try {
-      const files = readdirSync(config.output.dir);
+      const files = readdirSync2(config.output.dir);
       const planFiles = files.filter((f) => /^plan-[a-z]{2}(-[A-Z]{2})?\.json$/.test(f) && f !== basename(planPath));
       for (const file of planFiles) {
-        const filePath = join10(config.output.dir, file);
+        const filePath = join11(config.output.dir, file);
         try {
           const parsed = JSON.parse(await readFile4(filePath, "utf-8"));
           if (parsed.url && parsed.steps?.length > 0) {
@@ -3507,7 +4138,7 @@ async function runPlanPhase(params) {
     } catch {
     }
   }
-  if (!existingPlan && existsSync7(legacyPlanPath)) {
+  if (!existingPlan && existsSync8(legacyPlanPath)) {
     try {
       const parsed = JSON.parse(await readFile4(legacyPlanPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
@@ -3519,6 +4150,11 @@ async function runPlanPhase(params) {
   }
   const normalizeUrl2 = (u) => u.replace(/\/+$/, "").toLowerCase();
   const urlMatches = existingPlan && normalizeUrl2(existingPlan.url) === normalizeUrl2(url);
+  if (existingPlan && !urlMatches && isAutoYes()) {
+    console.log();
+    console.log(chalk10.dim(`  Existing plan is for ${existingPlan.url}, not ${url} \u2014 regenerating.`));
+    existingPlan = null;
+  }
   let plan;
   const doTranslate = async (failMsg) => {
     const translateTask = task(`Translating to ${targetLang}`);
@@ -3533,25 +4169,25 @@ async function runPlanPhase(params) {
       translateTask.fail(failMsg);
     }
   };
-  if (existingPlan && existingPlanPath) {
+  if (existingPlan && existingPlanPath && !fresh) {
     console.log();
-    console.log(chalk9.dim(`  Found existing plan: `) + chalk9.cyan(formatClickablePath(existingPlanPath)));
-    console.log(chalk9.dim(`  ${existingPlan.steps.length} steps for ${existingPlan.url}`));
+    console.log(chalk10.dim(`  Found existing plan: `) + chalk10.cyan(formatClickablePath(existingPlanPath)));
+    console.log(chalk10.dim(`  ${existingPlan.steps.length} steps for ${existingPlan.url}`));
     if (!urlMatches) {
-      console.log(chalk9.yellow(`  \u26A0 Plan URL differs from argument:`));
-      console.log(chalk9.yellow(`    Plan: ${existingPlan.url}`));
-      console.log(chalk9.yellow(`    Arg:  ${url}`));
+      console.log(chalk10.yellow(`  \u26A0 Plan URL differs from argument:`));
+      console.log(chalk10.yellow(`    Plan: ${existingPlan.url}`));
+      console.log(chalk10.yellow(`    Arg:  ${url}`));
     }
     const existingLang = existingPlan.lang || "en";
     if (existingLang !== targetLang) {
-      console.log(chalk9.yellow(`  \u26A0 Plan is in ${existingLang}, config is ${targetLang}`));
+      console.log(chalk10.yellow(`  \u26A0 Plan is in ${existingLang}, config is ${targetLang}`));
     }
     const reuse = await confirm(`${INDENT3}Use existing plan?`);
     if (reuse) {
       plan = await validateAndFixPlan(existingPlanPath, task, logError, userEmail, userTier);
       if (existingPlanPath !== planPath) {
         await savePlan(plan, planPath);
-        console.log(chalk9.dim(`  Migrated to: ${formatClickablePath(planPath)}`));
+        console.log(chalk10.dim(`  Migrated to: ${formatClickablePath(planPath)}`));
       }
       if (existingLang !== targetLang) {
         const translate = await confirm(`${INDENT3}Translate to ${targetLang}?`);
@@ -3569,7 +4205,8 @@ async function runPlanPhase(params) {
         userEmail,
         extensionPath,
         config.output.dir,
-        userTier
+        userTier,
+        { width: config.video.width, height: config.video.height }
       );
       displayRateLimitInfo();
       if (urlMatches) {
@@ -3586,7 +4223,7 @@ async function runPlanPhase(params) {
             uploadIdx++;
           }
         }
-        console.log(chalk9.dim(`  Preserved upload paths from previous plan`));
+        console.log(chalk10.dim(`  Preserved upload paths from previous plan`));
       }
       await savePlan(plan, planPath);
       plan = await validateAndFixPlan(planPath, task, logError, userEmail, userTier);
@@ -3602,7 +4239,9 @@ async function runPlanPhase(params) {
       logError,
       userEmail,
       extensionPath,
-      config.output.dir
+      config.output.dir,
+      void 0,
+      { width: config.video.width, height: config.video.height }
     );
     displayRateLimitInfo();
     await savePlan(plan, planPath);
@@ -3610,8 +4249,8 @@ async function runPlanPhase(params) {
   }
   displayPlanSummary(plan);
   console.log();
-  console.log(chalk9.dim(`  Plan: ${formatClickablePath(planPath)}`));
-  console.log(chalk9.dim(`  Enter a prompt to refine, or press Enter to continue.`));
+  console.log(chalk10.dim(`  Plan: ${formatClickablePath(planPath)}`));
+  console.log(chalk10.dim(`  Enter a prompt to refine, or press Enter to continue.`));
   const MAX_REFINEMENTS = 10;
   let refinementCount = 0;
   while (true) {
@@ -3629,15 +4268,15 @@ async function runPlanPhase(params) {
       refineTask.succeed("Plan refined");
       displayRateLimitInfo();
       if (plan.steps.length > maxSteps) {
-        console.log(chalk9.yellow(`  \u26A0 ${plan.steps.length} steps exceeds limit of ${maxSteps}`));
+        console.log(chalk10.yellow(`  \u26A0 ${plan.steps.length} steps exceeds limit of ${maxSteps}`));
       }
       displayPlanSummary(plan);
       console.log();
-      console.log(chalk9.dim(`  Plan: ${formatClickablePath(planPath)}`));
+      console.log(chalk10.dim(`  Plan: ${formatClickablePath(planPath)}`));
       if (refinementCount >= MAX_REFINEMENTS) {
         console.log();
-        console.log(chalk9.yellow(`  \u26A0 You've refined the plan ${MAX_REFINEMENTS} times.`));
-        console.log(chalk9.dim(`  Further refinements may incur additional costs.`));
+        console.log(chalk10.yellow(`  \u26A0 You've refined the plan ${MAX_REFINEMENTS} times.`));
+        console.log(chalk10.dim(`  Further refinements may incur additional costs.`));
         const continueRefining = await confirm(`${INDENT3}Continue refining?`);
         if (!continueRefining) break;
       }
@@ -3649,12 +4288,12 @@ async function runPlanPhase(params) {
   const planLang = plan.lang || "en";
   if (planLang !== targetLang) {
     let useExistingTranslation = false;
-    if (existsSync7(planPath) && existingPlanPath !== planPath) {
+    if (existsSync8(planPath) && existingPlanPath !== planPath) {
       try {
         const translatedPlan = JSON.parse(await readFile4(planPath, "utf-8"));
         if (translatedPlan.steps?.length === plan.steps.length && translatedPlan.lang === targetLang) {
           console.log();
-          console.log(chalk9.dim(`  Found translated plan: ${formatClickablePath(planPath)}`));
+          console.log(chalk10.dim(`  Found translated plan: ${formatClickablePath(planPath)}`));
           const useTranslated = await confirm(`${INDENT3}Use ${targetLang} translation?`);
           if (useTranslated) {
             plan = translatedPlan;
@@ -3666,7 +4305,7 @@ async function runPlanPhase(params) {
     }
     if (!useExistingTranslation) {
       console.log();
-      console.log(chalk9.yellow(`  Plan is in ${planLang}, but voice is set to ${targetLang}`));
+      console.log(chalk10.yellow(`  Plan is in ${planLang}, but voice is set to ${targetLang}`));
       const translate = await confirm(`${INDENT3}Translate captions to ${targetLang}?`);
       if (translate) await doTranslate("Translation failed, using original");
     }
@@ -3676,32 +4315,32 @@ async function runPlanPhase(params) {
 
 // src/commands/phases/validation-phase.ts
 import { readFile as readFile7 } from "fs/promises";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 
 // src/record.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir6 } from "fs/promises";
-import { join as join15 } from "path";
-import chalk10 from "chalk";
+import { existsSync as existsSync13 } from "fs";
+import { mkdir as mkdir7 } from "fs/promises";
+import { join as join16 } from "path";
+import chalk11 from "chalk";
 
 // src/browser/actions.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { readFile as readFile5 } from "fs/promises";
 import { isAbsolute as isAbsolute2, resolve as resolve5 } from "path";
 
 // src/browser/effects.ts
 init_lib();
-import { existsSync as existsSync8, readFileSync as readFileSync3 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { join as join12 } from "path";
 function loadHighlightCSS() {
   const candidates = [
-    join11(__dirname, "highlight.css"),
+    join12(__dirname, "highlight.css"),
     // dist/ build
-    join11(__dirname, "..", "highlight.css")
+    join12(__dirname, "..", "highlight.css")
     // src/browser/ → src/
   ];
   for (const p of candidates) {
-    if (existsSync8(p)) return readFileSync3(p, "utf-8");
+    if (existsSync9(p)) return readFileSync5(p, "utf-8");
   }
   return "";
 }
@@ -3901,6 +4540,10 @@ async function resolveElement(page, target) {
       await locator.waitFor({ state: "visible", timeout });
       return await locator.elementHandle({ timeout: 1e3 });
     }
+    if (target.startsWith("#") && !/^#[A-Za-z_-][\w-]*$/.test(target)) {
+      const attr = `[id="${target.slice(1).replace(/(["\\])/g, "\\$1")}"]`;
+      return await page.waitForSelector(attr, { state: "visible", timeout });
+    }
     return await page.waitForSelector(target, { state: "visible", timeout });
   } catch {
     return null;
@@ -4025,7 +4668,14 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
         }
       } else {
         const amount = direction === "up" ? -PAGE_SCROLL_PX : PAGE_SCROLL_PX;
-        await page.evaluate((y) => window.scrollBy(0, y), amount);
+        const moved = await page.evaluate((y) => {
+          const before = window.scrollY;
+          window.scrollBy(0, y);
+          return window.scrollY - before;
+        }, amount);
+        if (moved === 0) {
+          throw new Error("scroll moved nothing: the page has no scroll headroom at this viewport");
+        }
       }
       break;
     }
@@ -4043,7 +4693,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
           if (!isPlaceholder) {
             const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
             const filePath = isAbsolute2(normalizedPath) ? normalizedPath : resolve5(baseDir, normalizedPath);
-            if (existsSync9(filePath)) {
+            if (existsSync10(filePath)) {
               await fileInput.setInputFiles(filePath);
               await page.waitForTimeout(2e3);
               break;
@@ -4160,7 +4810,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
       break;
     case "image": {
       const imagePath = step.value ? isAbsolute2(step.value) ? step.value : resolve5(baseDir, step.value) : null;
-      if (imagePath && existsSync9(imagePath)) {
+      if (imagePath && existsSync10(imagePath)) {
         const imgStyle = step.target === "stretch" ? `width: ${config.video.width}px; height: ${config.video.height}px; object-fit: cover;` : "max-width: 90%; max-height: 90%;";
         if (await showImagePage(page, imagePath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -4190,7 +4840,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
         await pendingDownload;
         pendingDownload = null;
       }
-      if (lastDownloadPath && existsSync9(lastDownloadPath)) {
+      if (lastDownloadPath && existsSync10(lastDownloadPath)) {
         const imgStyle = step.target === "stretch" ? "width: 100%; height: 100%; object-fit: contain;" : "max-width: 90%; max-height: 90%; object-fit: contain;";
         if (await showImagePage(page, lastDownloadPath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -4235,22 +4885,22 @@ init_lib();
 
 // src/browser/dry-run.ts
 init_utils();
-import { join as join13 } from "path";
+import { join as join14 } from "path";
 
 // src/browser/step-validator.ts
 init_utils();
-import { existsSync as existsSync10, readdirSync as readdirSync2 } from "fs";
-import { basename as basename2, isAbsolute as isAbsolute3, join as join12, resolve as resolve6 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync3 } from "fs";
+import { basename as basename2, isAbsolute as isAbsolute3, join as join13, resolve as resolve6 } from "path";
 function findMediaFile(filename, baseDir) {
   const name = basename2(filename);
-  const searchDirs = [baseDir, join12(baseDir, "res"), join12(baseDir, "assets"), join12(baseDir, "media")];
+  const searchDirs = [baseDir, join13(baseDir, "res"), join13(baseDir, "assets"), join13(baseDir, "media")];
   for (const dir of searchDirs) {
-    if (!existsSync10(dir)) continue;
+    if (!existsSync11(dir)) continue;
     try {
-      const files = readdirSync2(dir);
-      if (files.includes(name)) return join12(dir, name);
+      const files = readdirSync3(dir);
+      if (files.includes(name)) return join13(dir, name);
       const match = files.find((f) => f.toLowerCase() === name.toLowerCase());
-      if (match) return join12(dir, match);
+      if (match) return join13(dir, match);
     } catch {
     }
   }
@@ -4323,7 +4973,7 @@ function resolveMediaStep(step, baseDir, label, startTime) {
     return { success: false, error: `Missing ${label} path`, executionTimeMs: Date.now() - startTime };
   }
   const specifiedPath = isAbsolute3(step.value) ? step.value : resolve6(baseDir, step.value);
-  if (existsSync10(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
+  if (existsSync11(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
   const foundPath = findMediaFile(step.value, baseDir);
   if (foundPath) {
     step.value = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -4445,7 +5095,7 @@ async function validateAndExecuteStep(page, step, plan, baseDir) {
         if (!isPlaceholder) {
           const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
           let filePath = isAbsolute3(normalizedPath) ? normalizedPath : resolve6(baseDir, normalizedPath);
-          if (!existsSync10(filePath)) {
+          if (!existsSync11(filePath)) {
             const foundPath = findMediaFile(rawPath, baseDir);
             if (foundPath) {
               const relativePath = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -4544,7 +5194,7 @@ async function getPageElements(page) {
   });
 }
 async function validateStepsOnPage(plan, config, logError2, baseDir, onStepStart, onStepEnd) {
-  const userDataDir = join13(baseDir, ".browser-data");
+  const userDataDir = join14(baseDir, ".browser-data");
   const { context, browser, chromeSession } = await launchBrowserContext(
     config,
     userDataDir,
@@ -4609,17 +5259,17 @@ async function validateStepsOnPage(plan, config, logError2, baseDir, onStepStart
 }
 
 // src/browser/meta.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { readFile as readFile6, writeFile as writeFile7 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 var RECORDING_FILE = "recording.mp4";
 var RECORDING_META_FILE = "recording.meta.json";
 function getRecordingPath(outputDir) {
-  return join14(outputDir, RECORDING_FILE);
+  return join15(outputDir, RECORDING_FILE);
 }
 async function loadRecordingMeta(outputDir) {
-  const metaPath = join14(outputDir, RECORDING_META_FILE);
-  if (!existsSync11(metaPath)) return null;
+  const metaPath = join15(outputDir, RECORDING_META_FILE);
+  if (!existsSync12(metaPath)) return null;
   try {
     const content = await readFile6(metaPath, "utf-8");
     return JSON.parse(content);
@@ -4628,7 +5278,7 @@ async function loadRecordingMeta(outputDir) {
   }
 }
 async function saveRecordingMeta(outputDir, meta) {
-  const metaPath = join14(outputDir, RECORDING_META_FILE);
+  const metaPath = join15(outputDir, RECORDING_META_FILE);
   await writeFile7(metaPath, JSON.stringify(meta, null, 2));
 }
 function canReuseRecording(plan, config, stepDurations, existingMeta) {
@@ -4698,15 +5348,15 @@ function formatStepLabel(step) {
   return `${caption.slice(0, 47)}...`;
 }
 async function recordSession(plan, config, stepDurations, workDir, baseDir, task2, logError2) {
-  const videoDir = join15(workDir, "video");
-  await mkdir6(videoDir, { recursive: true });
+  const videoDir = join16(workDir, "video");
+  await mkdir7(videoDir, { recursive: true });
   const getStepDuration = (stepNum) => {
     return stepDurations[stepNum - 1] ?? config.timing.minStepDuration;
   };
   const browserTask = task2("Starting browser recording");
   const recordingStartTime = Date.now();
-  const userDataDir = join15(workDir, "browser-data");
-  const recordVideo = { dir: videoDir, size: { width: config.video.width, height: config.video.height } };
+  const userDataDir = join16(workDir, "browser-data");
+  const recordVideo = { dir: videoDir, size: recordingViewport(config) };
   const authState = findAuthState(plan.url);
   const { context, browser, chromeSession } = await launchBrowserContext(config, userDataDir, recordVideo, authState);
   const page = context.pages()[0] || await context.newPage();
@@ -4727,6 +5377,7 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
   let onMediaPage = firstStepIsMedia;
   const failures = [];
   const actualStepDurations = [];
+  let pageClosedEarly = false;
   for (let i = 0; i < plan.steps.length; i++) {
     const step = plan.steps[i];
     const stepNum = i + 1;
@@ -4753,6 +5404,12 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
       let targetEl = null;
       if (step.target) {
         targetEl = await resolveElement(page, step.target);
+        if (!targetEl) {
+          console.log(
+            `
+    \u26A0 target "${step.target}" not found on page \u2014 step ${stepNum} recorded without the action`
+          );
+        }
       }
       if (step.zoom && step.zoom !== 1 && targetEl && !isExtensionPage) {
         const preZoomBox = await targetEl.boundingBox() ?? void 0;
@@ -4789,11 +5446,19 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
     }
     const stepElapsed = Date.now() - stepStartTime;
     const waitTime = Math.max(0, stepDuration - stepElapsed);
-    if (waitTime > 0) await page.waitForTimeout(waitTime);
     const stepDelay = config.video.stepDelay ?? 500;
     const isLastStep = i === plan.steps.length - 1;
-    if (!isLastStep && stepDelay > 0) {
-      await page.waitForTimeout(stepDelay);
+    try {
+      if (waitTime > 0) await page.waitForTimeout(waitTime);
+      if (!isLastStep && stepDelay > 0) await page.waitForTimeout(stepDelay);
+    } catch (err) {
+      if (page.isClosed()) {
+        console.log(chalk11.yellow("\n  \u26A0 Browser page closed early \u2014 saving the recording captured so far"));
+        pageClosedEarly = true;
+        actualStepDurations.push(Math.max(stepElapsed, stepDuration));
+        break;
+      }
+      throw err;
     }
     if (!isExtensionPage) {
       const shouldHighlight = step.highlight !== void 0 ? step.highlight : config.video.highlight;
@@ -4806,18 +5471,19 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
     actualStepDurations.push(actualDuration);
   }
   if (failures.length > 0) {
-    console.log(chalk10.yellow(`  \u26A0 ${failures.length} step(s) skipped:`));
+    console.log(chalk11.yellow(`  \u26A0 ${failures.length} step(s) skipped:`));
     for (const f of failures) {
-      console.log(chalk10.yellow(`    - ${f}`));
+      console.log(chalk11.yellow(`    - ${f}`));
     }
   }
+  while (actualStepDurations.length < plan.steps.length) actualStepDurations.push(0);
   const saveTask = task2("Saving video");
   const video = page.video();
   if (!video) throw new Error("No video recorder available");
-  await page.close();
+  if (!pageClosedEarly) await page.close();
   const videoPath = await video.path();
   await cleanupBrowserSession({ context, browser, chromeSession });
-  if (!videoPath || !existsSync12(videoPath)) {
+  if (!videoPath || !existsSync13(videoPath)) {
     throw new Error("Video file was not created");
   }
   saveTask.succeed("Video saved");
@@ -4876,21 +5542,21 @@ async function runValidationPhase(params) {
     const stepNum = result.stepIndex + 1;
     const step = plan.steps[result.stepIndex];
     console.log();
-    console.log(chalk11.red(`  \u2717 Step ${stepNum}: ${step.action}`));
+    console.log(chalk12.red(`  \u2717 Step ${stepNum}: ${step.action}`));
     const caption = step.caption || "";
-    if (caption) console.log(chalk11.dim(`    Caption: ${caption.slice(0, 50)}${caption.length > 50 ? "..." : ""}`));
-    console.log(chalk11.dim(`    Target: ${step.target || "none"}`));
-    if (step.value) console.log(chalk11.dim(`    Value: ${step.value}`));
-    console.log(chalk11.dim(`    Error: ${result.error}`));
+    if (caption) console.log(chalk12.dim(`    Caption: ${caption.slice(0, 50)}${caption.length > 50 ? "..." : ""}`));
+    console.log(chalk12.dim(`    Target: ${step.target || "none"}`));
+    if (step.value) console.log(chalk12.dim(`    Value: ${step.value}`));
+    console.log(chalk12.dim(`    Error: ${result.error}`));
     if (result.suggestion) {
-      console.log(chalk11.yellow(`    Hint: ${result.suggestion}`));
+      console.log(chalk12.yellow(`    Hint: ${result.suggestion}`));
     }
     console.log();
     const isUploadMissingFile = step.action === "upload" && (!step.value || step.value.startsWith("[") || step.value.includes("example") || step.value.includes("/path/to"));
     if (isUploadMissingFile) {
       const filePath = await promptInput('Enter file path to upload (or "skip"): ');
       if (filePath.toLowerCase() === "skip") {
-        console.log(chalk11.yellow(`  Skipping step ${stepNum}`));
+        console.log(chalk12.yellow(`  Skipping step ${stepNum}`));
         continue;
       }
       if (filePath) {
@@ -4899,13 +5565,13 @@ async function runValidationPhase(params) {
         const revalidation2 = await validateStepsOnPage(plan, config, logError, config.output.dir);
         const newResult2 = revalidation2.results[result.stepIndex];
         if (newResult2?.success) {
-          console.log(chalk11.green(`  \u2713 Step ${stepNum} now passes`));
+          console.log(chalk12.green(`  \u2713 Step ${stepNum} now passes`));
           validationResult = revalidation2;
           continue;
         }
         result.error = newResult2?.error;
         result.suggestion = newResult2?.suggestion;
-        console.log(chalk11.red(`  Still failing: ${result.error}`));
+        console.log(chalk12.red(`  Still failing: ${result.error}`));
       }
     }
     const fixTask = task(`Fixing step ${stepNum} with AI`);
@@ -4927,8 +5593,8 @@ async function runValidationPhase(params) {
       await savePlan(plan, planPath);
       fixTask.succeed("AI suggested a fix");
       const fixedStep = plan.steps[result.stepIndex];
-      console.log(chalk11.dim(`    New target: ${fixedStep.target || "none"}`));
-      if (fixedStep.value) console.log(chalk11.dim(`    New value: ${fixedStep.value}`));
+      console.log(chalk12.dim(`    New target: ${fixedStep.target || "none"}`));
+      if (fixedStep.value) console.log(chalk12.dim(`    New value: ${fixedStep.value}`));
     } catch {
       fixTask.fail("AI could not fix automatically");
     }
@@ -4944,11 +5610,11 @@ async function runValidationPhase(params) {
     result.error = newResult?.error;
     result.suggestion = newResult?.suggestion;
     console.log();
-    console.log(chalk11.yellow(`  Edit step ${stepNum} in: `) + chalk11.cyan(formatClickablePath(planPath)));
+    console.log(chalk12.yellow(`  Edit step ${stepNum} in: `) + chalk12.cyan(formatClickablePath(planPath)));
     console.log();
     const choice = await promptInput('Press Enter after editing, or type "skip" to skip this step: ');
     if (choice.toLowerCase() === "skip") {
-      console.log(chalk11.yellow(`  Skipping step ${stepNum} - may fail during recording`));
+      console.log(chalk12.yellow(`  Skipping step ${stepNum} - may fail during recording`));
       continue;
     }
     plan = JSON.parse(await readFile7(planPath, "utf-8"));
@@ -4976,17 +5642,17 @@ async function runValidationPhase(params) {
 
 // src/commands/phases/video-phase.ts
 init_lib();
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { copyFile } from "fs/promises";
-import { join as join17, resolve as resolve8 } from "path";
+import { join as join18, resolve as resolve8 } from "path";
 
 // src/utils/video-pipeline.ts
 init_lib();
 import { chunkWordsByCount, assTimeFromMs as formatASSTime } from "@spark-apps/video-kit";
-import { existsSync as existsSync13 } from "fs";
-import { mkdir as mkdir7, writeFile as writeFile8 } from "fs/promises";
-import { isAbsolute as isAbsolute4, join as join16, resolve as resolve7 } from "path";
-import chalk12 from "chalk";
+import { existsSync as existsSync14 } from "fs";
+import { mkdir as mkdir8, writeFile as writeFile8 } from "fs/promises";
+import { isAbsolute as isAbsolute4, join as join17, resolve as resolve7 } from "path";
+import chalk13 from "chalk";
 var INDENT4 = "   ";
 async function generateASS(plan, stepAudio, workDir, config, captions) {
   const regularColor = hexToAss(captions.regular.color);
@@ -5033,7 +5699,7 @@ async function generateASS(plan, stepAudio, workDir, config, captions) {
     }
     currentTime += audio.duration;
   }
-  const assPath = join16(workDir, "subtitles.ass");
+  const assPath = join17(workDir, "subtitles.ass");
   await writeFile8(assPath, ass);
   return assPath;
 }
@@ -5048,7 +5714,7 @@ function buildVideoOverlays(steps, stepDurations, baseDir) {
       const ext = step.value.split(".").pop()?.toLowerCase() || "";
       if (["mp4", "webm", "mov"].includes(ext)) {
         const mediaPath = isAbsolute4(step.value) ? step.value : resolve7(baseDir, step.value);
-        if (existsSync13(mediaPath)) {
+        if (existsSync14(mediaPath)) {
           const partial = parsePartial(step.partial);
           overlays.push({
             path: mediaPath,
@@ -5067,23 +5733,23 @@ function buildVideoOverlays(steps, stepDurations, baseDir) {
 }
 async function composeAndFinish(videoPath, audioPath, assPath, config, userTier = "free", mainContentDuration, trimStart = 0.5, stepTransitions, _stepSync) {
   header("Compose");
-  const configPath = join16(process.cwd(), CONFIG_FILE);
-  console.log(`${INDENT4}${chalk12.dim(`Config: ${formatClickablePath(configPath)}`)}`);
+  const configPath = join17(process.cwd(), CONFIG_FILE);
+  console.log(`${INDENT4}${chalk13.dim(`Config: ${formatClickablePath(configPath)}`)}`);
   const proceed = await confirm(`${INDENT4}Review config or continue?`);
   if (!proceed) {
-    console.log(chalk12.yellow(`
+    console.log(chalk13.yellow(`
   Edit ${CONFIG_FILE} and run again.
 `));
     process.exit(0);
   }
   const composeTask = task("Building final video");
-  await mkdir7(config.output.dir, { recursive: true });
+  await mkdir8(config.output.dir, { recursive: true });
   const suffix = config.lang ? `-${config.lang}` : "";
-  const finalPath = join16(config.output.dir, `demo${suffix}.${config.video.format}`);
+  const finalPath = join17(config.output.dir, `demo${suffix}.${config.video.format}`);
   const videoDuration = await getMediaDuration(videoPath) / 1e3;
-  const hasVoiceover = audioPath && existsSync13(audioPath);
+  const hasVoiceover = audioPath && existsSync14(audioPath);
   const musicPath = config.music?.path ? isAbsolute4(config.music.path) ? config.music.path : resolve7(config.output.dir, config.music.path) : "";
-  const hasMusic = musicPath && existsSync13(musicPath);
+  const hasMusic = musicPath && existsSync14(musicPath);
   try {
     await composeVideo({
       videoPath,
@@ -5122,7 +5788,7 @@ async function speedUpToFitLimit(finalPath, config, limitSecs = 60) {
   if (duration <= limitSecs * 1e3) return finalPath;
   const speedFactor = Math.ceil(duration / (limitSecs * 1e3) * 10) / 10;
   console.log();
-  console.log(chalk12.yellow(`  Video is ${(duration / 1e3).toFixed(0)}s - over ${limitSecs}s`));
+  console.log(chalk13.yellow(`  Video is ${(duration / 1e3).toFixed(0)}s - over ${limitSecs}s`));
   const speedUp = await confirm(`  Speed up ${speedFactor}x to fit under ${limitSecs}s?`);
   if (!speedUp) return finalPath;
   const speedTask = task(`Speeding up ${speedFactor}x`);
@@ -5145,6 +5811,21 @@ async function speedUpToFitLimit(finalPath, config, limitSecs = 60) {
 
 // src/commands/phases/video-phase.ts
 var INDENT5 = "   ";
+function resolveOutro(config, userTier) {
+  if (userTier !== "free") {
+    const custom = config.video.outro?.trim();
+    if (!custom) return void 0;
+    const path = resolve8(custom);
+    if (existsSync15(path)) return path;
+    info(`${INDENT5}\u26A0 outro not found: ${path}`);
+    return void 0;
+  }
+  const scriptDir = getScriptDir();
+  const bundled = join18(scriptDir, "assets", "qp.wm");
+  if (existsSync15(bundled)) return bundled;
+  const fallback = join18(scriptDir, "..", "dist", "assets", "qp.wm");
+  return existsSync15(fallback) ? fallback : void 0;
+}
 async function runVideoPhase(params) {
   let { stepAudio } = params;
   const { plan, config, voiceoverPath, workDir, captions, userTier } = params;
@@ -5163,7 +5844,7 @@ async function runVideoPhase(params) {
               mediaDuration = (trimEnd - trimStart2) * 1e3;
             } else {
               const mediaPath = resolve8(s.value);
-              if (existsSync14(mediaPath)) {
+              if (existsSync15(mediaPath)) {
                 try {
                   const fullDuration = await getMediaDuration(mediaPath);
                   const start = (trimStart2 ?? 0) * 1e3;
@@ -5175,7 +5856,7 @@ async function runVideoPhase(params) {
             }
           } else {
             const mediaPath = resolve8(s.value);
-            if (existsSync14(mediaPath)) {
+            if (existsSync15(mediaPath)) {
               try {
                 mediaDuration = await getMediaDuration(mediaPath);
               } catch {
@@ -5188,7 +5869,7 @@ async function runVideoPhase(params) {
     })
   );
   const recordingPath = getRecordingPath(config.output.dir);
-  const hasExistingRecording = existingRecordingMeta && existsSync14(recordingPath);
+  const hasExistingRecording = existingRecordingMeta && existsSync15(recordingPath);
   let videoPath = recordingPath;
   const firstStep = plan.steps[0];
   const firstStepIsVideo = firstStep && (firstStep.action === "video" || firstStep.action === "media");
@@ -5228,7 +5909,7 @@ async function runVideoPhase(params) {
   if (videoOverlays.length > 0) {
     const spliceTask = task("Splicing videos into recording");
     try {
-      const splicedPath = join17(workDir, "spliced.mp4");
+      const splicedPath = join18(workDir, "spliced.mp4");
       await spliceVideos({
         inputPath: videoPath,
         outputPath: splicedPath,
@@ -5248,8 +5929,8 @@ async function runVideoPhase(params) {
   if (stepTransitions.length > 0) {
     const transitionTask = task("Applying transitions");
     try {
-      const transitionedPath = join17(workDir, "transitioned.mp4");
-      const videoDuration = alignedStepDurations.reduce((a, b) => a + b, 0) / 1e3;
+      const transitionedPath = join18(workDir, "transitioned.mp4");
+      const videoDuration = await getMediaDuration(videoPath) / 1e3;
       await applyTransitions({
         inputVideo: videoPath,
         outputVideo: transitionedPath,
@@ -5267,30 +5948,24 @@ async function runVideoPhase(params) {
   const assPath = await generateASS(plan, stepAudio, workDir, config, captions);
   let videoToCompose = videoPath;
   let mainContentDuration;
-  if (userTier === "free") {
-    const scriptDir = getScriptDir();
-    let outroPath = join17(scriptDir, "assets", "qp.wm");
-    if (!existsSync14(outroPath)) {
-      outroPath = join17(scriptDir, "..", "dist", "assets", "qp.wm");
-    }
-    if (existsSync14(outroPath)) {
-      try {
-        const mainDuration = await getMediaDuration(videoPath);
-        mainContentDuration = mainDuration / 1e3 - trimStart;
-        const combinedPath = join17(workDir, "combined-with-outro.mp4");
-        await concatVideoWithOutro({
-          inputPath: videoPath,
-          outroPath,
-          outputPath: combinedPath,
-          width: config.video.width,
-          height: config.video.height,
-          preset: config.video.preset
-        });
-        videoToCompose = combinedPath;
-      } catch (err) {
-        await logError("Concat Outro", err);
-        mainContentDuration = void 0;
-      }
+  const outroPath = resolveOutro(config, userTier);
+  if (outroPath) {
+    try {
+      const mainDuration = await getMediaDuration(videoPath);
+      mainContentDuration = mainDuration / 1e3 - trimStart;
+      const combinedPath = join18(workDir, "combined-with-outro.mp4");
+      await concatVideoWithOutro({
+        inputPath: videoPath,
+        outroPath,
+        outputPath: combinedPath,
+        width: config.video.width,
+        height: config.video.height,
+        preset: config.video.preset
+      });
+      videoToCompose = combinedPath;
+    } catch (err) {
+      await logError("Concat Outro", err);
+      mainContentDuration = void 0;
     }
   }
   let finalPath = await composeAndFinish(
@@ -5325,18 +6000,18 @@ async function runVideoPhase(params) {
 
 // src/commands/phases/voiceover-phase.ts
 init_lib();
-import { existsSync as existsSync15 } from "fs";
-import { join as join18 } from "path";
-import chalk13 from "chalk";
+import { existsSync as existsSync16 } from "fs";
+import { join as join19 } from "path";
+import chalk14 from "chalk";
 var INDENT6 = "   ";
 async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
   if (fresh) {
     const filesToDelete = ["voiceover.json", "voiceover.wav", "recording.meta.json"];
     for (const file of filesToDelete) {
-      const filePath = join18(config.output.dir, file);
-      if (existsSync15(filePath)) {
-        const { unlink: unlink3 } = await import("fs/promises");
-        await unlink3(filePath).catch(() => {
+      const filePath = join19(config.output.dir, file);
+      if (existsSync16(filePath)) {
+        const { unlink: unlink4 } = await import("fs/promises");
+        await unlink4(filePath).catch(() => {
         });
       }
     }
@@ -5344,8 +6019,13 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
   }
   const voice = resolveVoice(config);
   const existingMeta = await loadVoiceoverMeta(config.output.dir);
-  const voiceoverFile = join18(config.output.dir, "voiceover.wav");
-  const hasExistingVoiceover = existingMeta && existsSync15(voiceoverFile);
+  const voiceoverFile = join19(config.output.dir, "voiceover.wav");
+  const voiceoverOnDisk = existingMeta && existsSync16(voiceoverFile);
+  const staleContainer = voiceoverOnDisk ? !await isHonestWav(voiceoverFile) : false;
+  if (staleContainer) {
+    info("Existing voiceover has a stale container, regenerating");
+  }
+  const hasExistingVoiceover = voiceoverOnDisk && !staleContainer;
   const voiceMatches = !existingMeta || !voice || existingMeta.voice === voice;
   let voiceoverPath;
   let stepAudio;
@@ -5368,9 +6048,9 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
     const reuseCheck = canReuseVoiceover(plan.steps, voice, existingMeta);
     if (reuseCheck.canReuse) {
       console.log();
-      console.log(chalk13.dim(`  Found existing voiceover in ${config.output.dir}`));
+      console.log(chalk14.dim(`  Found existing voiceover in ${config.output.dir}`));
       if (reuseCheck.reason) {
-        console.log(chalk13.dim(`  ${reuseCheck.reason}`));
+        console.log(chalk14.dim(`  ${reuseCheck.reason}`));
       }
       const reuse = await confirm(`${INDENT6}Reuse existing voiceover?`);
       if (reuse) {
@@ -5402,31 +6082,31 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
 }
 
 // src/commands/utils/chrome-extension.ts
-import { existsSync as existsSync16, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join19 } from "path";
+import { join as join20 } from "path";
 function resolveChromeExtension(extensionId) {
   const platform = process.platform;
   const possibleDirs = [];
   const getChromeExtDirs = (userDataPath) => {
     const dirs = [];
     try {
-      const profiles = readdirSync3(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
+      const profiles = readdirSync4(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
       for (const profile of profiles) {
-        dirs.push(join19(userDataPath, profile, "Extensions"));
+        dirs.push(join20(userDataPath, profile, "Extensions"));
       }
     } catch {
-      dirs.push(join19(userDataPath, "Default", "Extensions"));
+      dirs.push(join20(userDataPath, "Default", "Extensions"));
     }
     return dirs;
   };
   if (platform === "win32") {
-    possibleDirs.push(...getChromeExtDirs(join19(homedir3(), "AppData", "Local", "Google", "Chrome", "User Data")));
+    possibleDirs.push(...getChromeExtDirs(join20(homedir3(), "AppData", "Local", "Google", "Chrome", "User Data")));
   } else if (platform === "darwin") {
-    possibleDirs.push(...getChromeExtDirs(join19(homedir3(), "Library", "Application Support", "Google", "Chrome")));
+    possibleDirs.push(...getChromeExtDirs(join20(homedir3(), "Library", "Application Support", "Google", "Chrome")));
   } else {
     try {
-      const windowsUsers = readdirSync3("/mnt/c/Users").filter(
+      const windowsUsers = readdirSync4("/mnt/c/Users").filter(
         (u) => !["All Users", "Default", "Default User", "Public", "desktop.ini"].includes(u)
       );
       for (const user of windowsUsers) {
@@ -5434,22 +6114,22 @@ function resolveChromeExtension(extensionId) {
       }
     } catch {
     }
-    possibleDirs.push(...getChromeExtDirs(join19(homedir3(), ".config", "google-chrome")));
+    possibleDirs.push(...getChromeExtDirs(join20(homedir3(), ".config", "google-chrome")));
   }
   for (const chromeExtDir of possibleDirs) {
-    const extDir = join19(chromeExtDir, extensionId);
-    if (!existsSync16(extDir)) continue;
+    const extDir = join20(chromeExtDir, extensionId);
+    if (!existsSync17(extDir)) continue;
     try {
-      const versions = readdirSync3(extDir).filter((f) => !f.startsWith("."));
+      const versions = readdirSync4(extDir).filter((f) => !f.startsWith("."));
       if (versions.length === 0) continue;
       const latestVersion = versions.sort().pop();
-      const extPath = join19(extDir, latestVersion);
+      const extPath = join20(extDir, latestVersion);
       let name = extensionId;
       let popupPath = "popup.html";
-      const manifestPath = join19(extPath, "manifest.json");
-      if (existsSync16(manifestPath)) {
+      const manifestPath = join20(extPath, "manifest.json");
+      if (existsSync17(manifestPath)) {
         try {
-          const manifest = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+          const manifest = JSON.parse(readFileSync6(manifestPath, "utf-8"));
           if (manifest.name && !manifest.name.startsWith("__MSG_")) {
             name = manifest.name;
           }
@@ -5480,16 +6160,23 @@ async function recordCommand(url, options = {}) {
     const extensionId = url.slice(7);
     chromeExtension = resolveChromeExtension(extensionId);
     if (!chromeExtension) {
-      console.log(chalk14.red(`
+      console.log(chalk15.red(`
   \u2717 Chrome extension not found: ${extensionId}`));
-      console.log(chalk14.dim(`    Make sure the extension is installed in Chrome
+      console.log(chalk15.dim(`    Make sure the extension is installed in Chrome
 `));
       process.exit(1);
     }
     config.browser = { extension: chromeExtension.path };
     url = chromeExtension.popupUrl;
-    console.log(chalk14.dim(`  Extension: ${chromeExtension.name}`));
-    console.log(chalk14.dim(`  Path: ${chromeExtension.path}`));
+    console.log(chalk15.dim(`  Extension: ${chromeExtension.name}`));
+    console.log(chalk15.dim(`  Path: ${chromeExtension.path}`));
+  }
+  if (!chromeExtension) {
+    const startUrl = resolveStartUrl(url);
+    if (startUrl !== url) {
+      console.log(chalk15.dim(`  Signed-in start page: ${startUrl}`));
+      url = startUrl;
+    }
   }
   config.output.dir = chromeExtension ? `./${chromeExtension.name.toLowerCase().replace(/[^a-z0-9]+/g, "-")}-demo` : getOutputDirFromUrl(url);
   const userData = await loadUserData();
@@ -5502,20 +6189,20 @@ async function recordCommand(url, options = {}) {
   if (!authResult) return;
   const { userEmail, userTier, localVideoCount } = authResult;
   if (configCreated) {
-    const configPath = join20(process.cwd(), CONFIG_FILE);
+    const configPath = join21(process.cwd(), CONFIG_FILE);
     console.log();
-    console.log(chalk14.green(`  \u2714 Created ${CONFIG_FILE}`));
-    console.log(chalk14.dim(`    ${configPath}`));
+    console.log(chalk15.green(`  \u2714 Created ${CONFIG_FILE}`));
+    console.log(chalk15.dim(`    ${configPath}`));
     console.log();
-    console.log(chalk14.cyan("  Review the config file to customize:"));
-    console.log(chalk14.dim("    \u2022 lang: Voice language (en, es, ar, zh...)"));
-    console.log(chalk14.dim("    \u2022 video: Resolution, quality, effects"));
-    console.log(chalk14.dim("    \u2022 music: Background music path and volume"));
-    console.log(chalk14.dim("    \u2022 output: Output directory"));
+    console.log(chalk15.cyan("  Review the config file to customize:"));
+    console.log(chalk15.dim("    \u2022 lang: Voice language (en, es, ar, zh...)"));
+    console.log(chalk15.dim("    \u2022 video: Resolution, quality, effects"));
+    console.log(chalk15.dim("    \u2022 music: Background music path and volume"));
+    console.log(chalk15.dim("    \u2022 output: Output directory"));
     console.log();
     const proceed = await confirm(`${INDENT2}Proceed with default settings?`);
     if (!proceed) {
-      console.log(chalk14.yellow(`
+      console.log(chalk15.yellow(`
   Edit ${CONFIG_FILE} and run again.
 `));
       process.exit(0);
@@ -5524,16 +6211,16 @@ async function recordCommand(url, options = {}) {
   if (langOverride) config.lang = langOverride;
   if (config.music?.path) {
     const musicPath = isAbsolute5(config.music.path) ? config.music.path : resolve9(config.output.dir, config.music.path);
-    if (!existsSync17(musicPath)) {
+    if (!existsSync18(musicPath)) {
       console.log();
-      console.log(chalk14.yellow(`  \u26A0 Music file not found: ${config.music.path}`));
-      console.log(chalk14.dim(`    Config: ${join20(process.cwd(), CONFIG_FILE)}`));
+      console.log(chalk15.yellow(`  \u26A0 Music file not found: ${config.music.path}`));
+      console.log(chalk15.dim(`    Config: ${join21(process.cwd(), CONFIG_FILE)}`));
       console.log();
       const proceed = await confirm(`${INDENT2}Continue without background music?`);
       if (!proceed) {
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
   Edit music.path in config and run again.`));
-        console.log(chalk14.dim(`    ${join20(process.cwd(), CONFIG_FILE)}
+        console.log(chalk15.dim(`    ${join21(process.cwd(), CONFIG_FILE)}
 `));
         process.exit(0);
       }
@@ -5543,10 +6230,10 @@ async function recordCommand(url, options = {}) {
   const captions = await loadCaptions();
   const workDir = await prepareWorkDir();
   const targetLang = config.lang || "en";
-  const planPath = join20(config.output.dir, `plan-${targetLang}.json`);
-  const legacyPlanPath = join20(config.output.dir, "plan.json");
+  const planPath = join21(config.output.dir, `plan-${targetLang}.json`);
+  const legacyPlanPath = join21(config.output.dir, "plan.json");
   const isExtensionUrl = url.startsWith("chrome-extension://");
-  await mkdir8(config.output.dir, { recursive: true });
+  await mkdir9(config.output.dir, { recursive: true });
   await setLogFilePath(config.output.dir);
   try {
     const plan = await runPlanPhase({
@@ -5557,7 +6244,8 @@ async function recordCommand(url, options = {}) {
       ...description !== void 0 && { description },
       planPath,
       legacyPlanPath,
-      targetLang
+      targetLang,
+      ...fresh !== void 0 && { fresh }
     });
     const validatedPlan = await runValidationPhase({
       plan,
@@ -5582,49 +6270,58 @@ async function recordCommand(url, options = {}) {
       await saveUserData({ localVideoCount: newCount });
       const remaining = FREE_VIDEO_LIMIT - newCount;
       if (remaining > 0) {
-        console.log(chalk14.dim(`  ${remaining} free video${remaining === 1 ? "" : "s"} remaining`));
+        console.log(chalk15.dim(`  ${remaining} free video${remaining === 1 ? "" : "s"} remaining`));
       }
     }
     console.log();
-    console.log(chalk14.bold.green("  \u2713 Done!"));
+    console.log(chalk15.bold.green("  \u2713 Done!"));
     console.log();
-    console.log(chalk14.cyan(`  ${formatClickablePath(finalPath)}`));
+    console.log(chalk15.cyan(`  ${formatClickablePath(finalPath)}`));
     console.log();
     return finalPath;
   } catch (err) {
     await logError("Record Command", err);
     if (rethrow) throw err;
     console.log();
-    console.log(chalk14.red(`  Error: ${err instanceof Error ? err.message : "Unknown error"}`));
-    console.log(chalk14.dim(`  See ${logFilePath} for details`));
+    console.log(chalk15.red(`  Error: ${err instanceof Error ? err.message : "Unknown error"}`));
+    console.log(chalk15.dim(`  See ${logFilePath} for details`));
     process.exit(1);
   }
 }
 
 // src/commands/script-cmd.ts
 import { readFile as readFile8 } from "fs/promises";
-import { join as join21 } from "path";
-import chalk15 from "chalk";
+import { join as join22 } from "path";
+import chalk16 from "chalk";
 
 // src/ai/narrate.ts
 init_lib();
-async function generatePlanFromScript(captions, url, title, pageElementsText, lang, logError2, userEmail, tier = "free") {
+var SCRIPT_ACTIONS = /* @__PURE__ */ new Set(["click", "type", "scroll", "wait", "select", "check", "navigate"]);
+var NEEDS_TARGET = /* @__PURE__ */ new Set(["click", "type", "select", "check", "navigate"]);
+function isUsableStep(step) {
+  if (!step?.action || !SCRIPT_ACTIONS.has(step.action)) return false;
+  if (NEEDS_TARGET.has(step.action) && !step.target) return false;
+  if (step.action === "navigate" && !/^https?:\/\//.test(step.target ?? "")) return false;
+  return true;
+}
+async function generatePlanFromScript(captions, url, title, pageElementsText, lang, logError2, userEmail, tier = "free", task2) {
   const systemPrompt = `You map narration sentences to web UI actions.
-Given page elements and a script, return a JSON demo plan.
+Given page elements and a numbered script, return one action per script line.
 
 RULES:
-- Return ONLY valid JSON
-- Preserve captions EXACTLY as given \u2014 never alter the text
+- Return ONLY valid JSON, no explanation, no captions
+- Return exactly one entry per script line, in order, with "line" set to that line's number
 - Use page elements to pick realistic actions/targets
-- If a caption doesn't match a specific UI action, use { "action": "wait" }
+- If a line doesn't match a specific UI action, use { "action": "wait" }
+- Keep every target and value short
 
 ACTION FORMATS:
-\u2022 click: { "action": "click", "target": "button text" }
-\u2022 type: { "action": "type", "target": "input selector", "value": "text from caption" }
-\u2022 scroll: { "action": "scroll", "value": "up|down" }
-\u2022 wait: { "action": "wait" }
+\u2022 click: { "line": 1, "action": "click", "target": "button text" }
+\u2022 type: { "line": 2, "action": "type", "target": "input selector", "value": "text to type" }
+\u2022 scroll: { "line": 3, "action": "scroll", "value": "up|down" }
+\u2022 wait: { "line": 4, "action": "wait" }
 
-OUTPUT: full plan JSON with url, title, description, steps[]`;
+OUTPUT: {"description":"one short sentence","steps":[ ... ]}`;
   const scriptLines = captions.map((c, i) => `${i + 1}. "${c}"`).join("\n");
   const userMessage = `URL: ${url}
 App: ${title}
@@ -5632,48 +6329,108 @@ App: ${title}
 Available page elements:
 ${pageElementsText}
 
-Narration script (map each line to a UI action, preserve caption text exactly):
+Narration script (map each line to a UI action):
 ${scriptLines}
 
-Return the full plan JSON.`;
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const jsonMatch = content.match(/\{[\s\S]*\}/);
-  if (!jsonMatch) throw new Error("No JSON in AI script response");
-  const plan = JSON.parse(jsonMatch[0]);
-  plan.url = url;
-  if (lang !== void 0) plan.lang = lang;
-  plan.steps = plan.steps.map(({ duration: _d, ...s }, i) => ({
-    ...s,
-    id: i + 1,
-    caption: captions[i] ?? s.caption ?? ""
-  }));
-  return plan;
+Return JSON with a "description" and a "steps" array of exactly ${captions.length} actions.`;
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "narration");
+  const parsed = await parseAIJsonWithRepair(content, {
+    logError: logError2,
+    task: task2,
+    userEmail,
+    tier,
+    shape: "The JSON should have: description (string), steps (array of {line, action, target, value}).",
+    context: "Script Plan"
+  });
+  const raw = Array.isArray(parsed?.steps) ? parsed.steps : [];
+  const byLine = /* @__PURE__ */ new Map();
+  raw.forEach((step, i) => {
+    if (!step || typeof step !== "object") return;
+    const line = typeof step.line === "number" && step.line >= 1 ? step.line : i + 1;
+    if (!byLine.has(line)) byLine.set(line, step);
+  });
+  const steps = captions.map((caption, i) => {
+    const mapped = byLine.get(i + 1);
+    if (!isUsableStep(mapped)) {
+      return { id: i + 1, action: "wait", caption };
+    }
+    return {
+      id: i + 1,
+      action: mapped.action,
+      caption,
+      ...mapped.target ? { target: mapped.target } : {},
+      ...mapped.value ? { value: mapped.value } : {}
+    };
+  });
+  return {
+    url,
+    title,
+    description: typeof parsed?.description === "string" ? parsed.description : title,
+    ...lang !== void 0 ? { lang } : {},
+    steps
+  };
 }
 
 // src/commands/script-cmd.ts
 init_lib();
 init_config_loader();
+async function reusablePlan(planPath, lines) {
+  try {
+    const plan = JSON.parse(await readFile8(planPath, "utf-8"));
+    if (!Array.isArray(plan.steps)) return null;
+    if (plan.steps.length < lines.length) return null;
+    const matches = lines.every((line, i) => plan.steps[i]?.caption === line);
+    return matches ? plan : null;
+  } catch {
+    return null;
+  }
+}
 async function scriptCommand(url, scriptPath, lang) {
+  url = resolveStartUrl(url);
   const { config, workDir, captions } = await initCommandEnv(url, lang);
+  const userData = await loadUserData();
+  const userTier = userData.email ? await getTierByEmail(userData.email) : "free";
   header("Script");
   const raw = await readFile8(scriptPath, "utf-8");
   const lines = raw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
   if (lines.length === 0) {
-    console.log(chalk15.red("  Script file is empty or has no non-comment lines"));
+    console.log(chalk16.red("  Script file is empty or has no non-comment lines"));
     process.exit(1);
   }
   info(`${lines.length} captions from script`);
+  const maxSteps = config.plan?.maxSteps ?? 8;
+  if (lines.length > maxSteps) {
+    console.log(
+      chalk16.yellow(`  \u26A0 ${lines.length} script lines exceeds plan.maxSteps (${maxSteps}) \u2014 recording all of them.`)
+    );
+    console.log(chalk16.dim(`    Raise plan.maxSteps in quickpeek.config.json to silence this, or split the script.`));
+  }
   header("Analyze");
   const crawlTask = task("Crawling page for UI elements");
-  const { elements } = await crawlPage(url, () => crawlTask);
+  const { elements } = await crawlPage(url, () => crawlTask, findAuthState(url));
   const elementsText = elements.slice(0, 30).map((e) => `  ${e.action}: ${e.text} (${e.selector})`).join("\n");
   header("Plan");
   const planTask = task("Mapping script to UI actions");
   const appTitle = new URL(url).hostname.replace(/^www\./, "");
-  const plan = await generatePlanFromScript(lines, url, appTitle, elementsText, lang, logError);
-  const planPath = join21(config.output.dir, `plan-${lang ?? "en"}.json`);
-  await savePlan(plan, planPath);
-  planTask.succeed(`${plan.steps.length} steps planned`);
+  const planPath = join22(config.output.dir, `plan-${lang ?? "en"}.json`);
+  let plan = await reusablePlan(planPath, lines);
+  if (plan) {
+    planTask.succeed(`${plan.steps.length} steps reused from existing plan`);
+  } else {
+    plan = await generatePlanFromScript(
+      lines,
+      url,
+      appTitle,
+      elementsText,
+      lang,
+      logError,
+      userData.email,
+      userTier,
+      () => planTask
+    );
+    await savePlan(plan, planPath);
+    planTask.succeed(`${plan.steps.length} steps planned`);
+  }
   header("Voiceover");
   const { voiceoverPath, stepAudio } = await generateVoiceover(
     plan.steps,
@@ -5689,14 +6446,116 @@ async function scriptCommand(url, scriptPath, lang) {
   const { videoPath } = await recordSession(plan, config, stepDurations, workDir, config.output.dir, task, logError);
   header("Compose");
   const assPath = await generateASS(plan, stepAudio, workDir, config, captions);
-  const finalPath = await composeAndFinish(videoPath, voiceoverPath, assPath, config, "free");
+  const finalPath = await composeAndFinish(videoPath, voiceoverPath, assPath, config, userTier);
   console.log();
-  console.log(chalk15.bold.green("  Done!"));
-  console.log(chalk15.cyan(`  ${finalPath}`));
+  console.log(chalk16.bold.green("  Done!"));
+  console.log(chalk16.cyan(`  ${finalPath}`));
 }
 
 // src/mcp/tools.ts
 init_SparkStripe_feature_gating();
+
+// src/mcp/delegate.ts
+init_SparkStripe_feature_gating();
+var STEPS = {
+  plan: {
+    field: "plan",
+    shape: "the demo plan, as the JSON object the instructions describe"
+  },
+  fix: {
+    field: "fix",
+    shape: "the corrected steps, as the JSON object the instructions describe"
+  },
+  narration: {
+    field: "narration",
+    shape: "the narration, as the JSON object the instructions describe"
+  }
+};
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function section(e, index) {
+  const { field, shape } = STEPS[e.step];
+  return [`### ${index}. ${field}`, ``, e.system, ``, e.prompt, ``, `Answer as \`${field}\`: ${shape}`].join("\n");
+}
+function delegatedBrief(pending2) {
+  const tool = pending2[0]?.tool ?? "this tool";
+  const fields = pending2.map((e) => STEPS[e.step].field);
+  return textResult(
+    [
+      `\`${tool}\` needs ${pending2.length === 1 ? "a piece of" : `${pending2.length} pieces of`} writing,`,
+      `and you are a stronger model than the one this CLI would relay to, so it is yours to`,
+      `do. QuickPeek never generates on your behalf.`,
+      ``,
+      ...pending2.map((e, i) => `${section(e, i + 1)}
+`),
+      `## Next`,
+      ``,
+      `Call \`${tool}\` again with the same arguments plus \`ai\`:`,
+      ``,
+      "```json",
+      `{ "ai": { ${fields.map((f) => `"${f}": ...`).join(", ")} } }`,
+      "```",
+      ``,
+      `Each value is used verbatim and no further writing is asked for.`
+    ].join("\n")
+  );
+}
+async function callerTier() {
+  const { loadUserData: loadUserData2 } = await Promise.resolve().then(() => (init_config_loader(), config_loader_exports));
+  const userData = await loadUserData2();
+  if (!userData.email) return "free";
+  try {
+    return await getTierByEmail(userData.email);
+  } catch {
+    return "free";
+  }
+}
+async function withDelegation(tool, args, fn) {
+  const answers = args.ai ?? {};
+  const tier = await callerTier();
+  try {
+    const result = await runInMcpTool(tool, fn, answers);
+    const pending2 = pendingDelegations();
+    return pending2.length ? delegatedBrief(pending2) : withTierNote(result, tier);
+  } catch (e) {
+    const pending2 = pendingDelegations();
+    if (pending2.length) return delegatedBrief(pending2);
+    if (e instanceof DelegatedGenerationError) return delegatedBrief([e]);
+    throw e;
+  }
+}
+function withTierNote(result, tier) {
+  if (tier !== "free") return result;
+  return {
+    ...result,
+    content: [
+      ...result.content,
+      {
+        type: "text",
+        text: `Free tier: this demo carries a watermark and the free video limit applies. Upgrade at ${pricingUrl()}`
+      }
+    ]
+  };
+}
+
+// src/mcp/elicit.ts
+var elicit = null;
+var canPrompt = null;
+function setElicit(fn) {
+  elicit = fn;
+}
+function setCanElicit(fn) {
+  canPrompt = fn;
+}
+function canElicit() {
+  return canPrompt ? canPrompt() : elicit !== null;
+}
+async function askUser(message) {
+  return elicit ? elicit(message) : null;
+}
+
+// src/mcp/tools.ts
 var URL_PROPERTY = {
   url: {
     type: "string",
@@ -5709,15 +6568,27 @@ var LANG_PROPERTY = {
     description: 'ISO 639-1 language for narration and captions (e.g. "en", "fr"). Default from config.'
   }
 };
+var SKIP_AUTH_PROPERTY = {
+  skip_auth: {
+    type: "boolean",
+    description: "Record without signing in. By default, a URL with no saved session prompts the user to sign in first so the demo covers the app, not the logged-out landing page. Pass true only for public sites with nothing behind a login, or when a logged-out demo is intended."
+  }
+};
 var QUICKPEEK_TOOLS = [
   {
     name: "generate_demo",
-    description: "Record a narrated demo video of a web app, end to end: an AI plans the walkthrough, Playwright drives a real browser, and the result is composed with voiceover and burned karaoke captions. This is the headline tool. It takes minutes, not seconds, because a real browser session is recorded. Returns the finished MP4 path and a file:// url. Pages behind a login can be demoed after the user runs `qp auth <url>` once in a terminal; the saved session is picked up automatically.",
+    description: "Record a narrated demo video of a web app, end to end: an AI plans the walkthrough, Playwright drives a real browser, and the result is composed with voiceover and burned karaoke captions. This is the headline tool. It takes minutes, not seconds, because a real browser session is recorded. Returns the finished MP4 path and a file:// url. If the host has no saved session, the user is first prompted to sign in (a visible browser opens; QuickPeek never sees the password) so the demo starts inside the app, usually the dashboard, instead of the logged-out landing page. Pass skip_auth for public sites. The result says whether this recording was signed in.",
     inputSchema: {
       type: "object",
       properties: {
+        ai: {
+          type: "object",
+          description: `Writing you produced from this tool's brief, keyed by the fields it asked for (e.g. {"plan": {...}}). Each value is used verbatim and no AI call is made for it. Omit on the first call: the tool will tell you what it needs. This server never generates text itself - you are the model it delegates to.`,
+          additionalProperties: true
+        },
         ...URL_PROPERTY,
         ...LANG_PROPERTY,
+        ...SKIP_AUTH_PROPERTY,
         description: {
           type: "string",
           description: "What the demo should focus on, in your words. Steers the AI plan. Without it, the planner infers the story from the page itself."
@@ -5736,20 +6607,49 @@ var QUICKPEEK_TOOLS = [
   },
   {
     name: "generate_demo_from_script",
-    description: "Record a demo that follows a script you supply, one caption per line, instead of an AI-planned walkthrough. The AI still maps each line to a UI action. Use when you know exactly what the video should say and in what order.",
+    description: "Record a demo that follows a script you supply, one caption per line, instead of an AI-planned walkthrough. The AI still maps each line to a UI action. Use when you know exactly what the video should say and in what order. Prompts for sign-in like generate_demo when the host has no saved session.",
     inputSchema: {
       type: "object",
       properties: {
+        ai: {
+          type: "object",
+          description: `Writing you produced from this tool's brief, keyed by the fields it asked for (e.g. {"plan": {...}}). Each value is used verbatim and no AI call is made for it. Omit on the first call: the tool will tell you what it needs. This server never generates text itself - you are the model it delegates to.`,
+          additionalProperties: true
+        },
         ...URL_PROPERTY,
         script_path: {
           type: "string",
           description: "Path to a plain text file with one sentence or caption per line."
         },
-        ...LANG_PROPERTY
+        ...LANG_PROPERTY,
+        ...SKIP_AUTH_PROPERTY
       },
       required: ["url", "script_path"]
     }
   },
+  {
+    name: "open_in_editor",
+    description: "Open a recorded demo's plan in the browser editor, where the user can reword captions, reorder steps or drop them. The plan travels in the URL fragment, so nothing is uploaded; saving in the editor writes back over the same file and the next recording picks it up. Records nothing itself.",
+    inputSchema: {
+      type: "object",
+      properties: { ...URL_PROPERTY, ...LANG_PROPERTY },
+      required: ["url"]
+    }
+  },
+  {
+    name: "start_auth",
+    description: "Open a visible browser on a site so the user can sign in, once, by hand. Everything recorded afterwards starts from that session, and demos of the bare URL begin on the page the user leaves open when the session is saved \u2014 tell them to finish on their dashboard. QuickPeek never sees the password: only the resulting cookies are saved. On clients that support prompting, this saves the session as soon as the user confirms; otherwise call finish_auth when they say they are done.",
+    inputSchema: {
+      type: "object",
+      properties: { ...URL_PROPERTY },
+      required: ["url"]
+    }
+  },
+  {
+    name: "finish_auth",
+    description: "Save the session from the browser window start_auth opened, and close it. Call this once the user says they have signed in.",
+    inputSchema: { type: "object", properties: {} }
+  },
   {
     name: "list_demos",
     description: "List demo videos already produced for a URL, newest first, with size and modified time. Cheap: reads the output directory, records nothing.",
@@ -5779,9 +6679,38 @@ var QUICKPEEK_TOOLS = [
     inputSchema: { type: "object", properties: {} }
   }
 ];
+async function ensureSignedIn(url, skipAuth) {
+  if (!url.startsWith("http") || skipAuth || findAuthState(url)) return null;
+  const host = new URL(url).host;
+  const authRequired = () => ({
+    ...jsonContent({
+      status: "auth_required",
+      host,
+      message: `No saved sign-in for ${host}, so the demo would only show logged-out pages. Ask the user how to proceed: to demo the app signed in, call start_auth with this url, then finish_auth once they confirm, and retry. For a public site with no login, retry with skip_auth: true.`
+    }),
+    isError: true
+  });
+  if (!canElicit()) return authRequired();
+  await openSignIn(url);
+  const confirmed = await askUser(
+    `No saved sign-in for ${host}. A browser window is open: sign in there and leave it on the page the demo should start from (usually your dashboard), then confirm. Decline to record logged out.`
+  );
+  if (confirmed === null) {
+    await cancelSignIn();
+    return authRequired();
+  }
+  if (confirmed) {
+    await saveSignIn();
+    return null;
+  }
+  await cancelSignIn();
+  return null;
+}
 async function handleGenerateDemo(args) {
   const url = resolveUrl(args.url);
   return withSilencedStdout(async () => {
+    const authGate = await ensureSignedIn(url, args.skip_auth);
+    if (authGate) return authGate;
     const output = await recordCommand(url, {
       langOverride: args.lang,
       description: args.description,
@@ -5793,7 +6722,11 @@ async function handleGenerateDemo(args) {
       rethrow: true
     });
     if (!output) return errorContent("Recording finished without producing a video.");
-    return fileResult(output, { name: output.split("/").pop(), url_recorded: url, auth: authStatus(url) });
+    return fileResult(output, {
+      name: output.split("/").pop(),
+      url_recorded: resolveStartUrl(url),
+      auth: authStatus(url)
+    });
   });
 }
 function authStatus(url) {
@@ -5803,23 +6736,74 @@ function authStatus(url) {
   return {
     signedIn: false,
     host,
-    note: `No saved session for ${host}, so only pages reachable while logged out were recorded. To cover pages behind the login, ask the user to run \`qp auth ${url}\` in a terminal and sign in once, then re-run with fresh: true.`
+    note: `No saved session for ${host}, so only pages reachable while logged out were recorded. To cover pages behind the login, call start_auth with this url (or have the user run \`qp auth ${url}\`), then re-run with fresh: true and without skip_auth.`
   };
 }
 async function handleGenerateDemoFromScript(args) {
   const url = resolveUrl(args.url);
   const scriptPath = resolveInputPath(args.script_path);
   return withSilencedStdout(async () => {
+    const authGate = await ensureSignedIn(url, args.skip_auth);
+    if (authGate) return authGate;
     await scriptCommand(url, scriptPath, args.lang);
     const dir = getOutputDirFromUrl(url);
     const newest = newestVideo(dir);
     if (!newest) return errorContent(`No video found in ${dir} after running the script.`);
-    return fileResult(newest, { name: newest.split("/").pop(), url_recorded: url, scriptPath });
+    return fileResult(newest, { name: newest.split("/").pop(), url_recorded: resolveStartUrl(url), scriptPath });
+  });
+}
+async function handleOpenInEditor(args) {
+  const url = resolveUrl(args.url);
+  return withSilencedStdout(async () => {
+    const dir = getOutputDirFromUrl(url);
+    const planPath = findPlanFile(dir, args.lang);
+    if (!planPath) {
+      return errorContent(`No plan found in ${dir}. Record the demo first with generate_demo.`);
+    }
+    const parsed = parsePlanText(readFileSync7(planPath, "utf8"));
+    if (!parsed.ok) return errorContent(`${planPath} cannot be opened: ${parsed.error}`);
+    const base = editorBaseUrl();
+    const editorUrl = planEditorUrl(base, parsed.plan);
+    await openInBrowser(editorUrl ?? `${base}/edit`);
+    return jsonContent({
+      opened: true,
+      plan_path: planPath,
+      steps: parsed.plan.steps.length,
+      url: editorUrl ?? `${base}/edit`,
+      next_steps: editorUrl ? ["The editor opens with the plan loaded.", "Saving there writes back over plan_path; then re-record."] : [`This plan is too long for a link. Load ${planPath} in the editor by hand.`]
+    });
+  });
+}
+async function handleStartAuth(args) {
+  const url = resolveUrl(args.url);
+  return withSilencedStdout(async () => {
+    await openSignIn(url);
+    const confirmed = await askUser(
+      `A browser window is open on ${url}. Sign in there, leave it on the page demos should start from (usually your dashboard), then confirm.`
+    );
+    if (confirmed === null) {
+      return jsonContent({
+        status: "awaiting_sign_in",
+        url,
+        next: "A browser window is open. Call finish_auth once the user says they are signed in."
+      });
+    }
+    if (!confirmed) {
+      await cancelSignIn();
+      return jsonContent({ status: "cancelled", url, note: "Nothing was saved." });
+    }
+    return jsonContent({ status: "saved", ...await saveSignIn() });
+  });
+}
+async function handleFinishAuth() {
+  return withSilencedStdout(async () => {
+    if (!pendingSignIn()) return errorContent("No sign-in window is open. Call start_auth first.");
+    return jsonContent({ status: "saved", ...await saveSignIn() });
   });
 }
 function newestVideo(dir) {
   try {
-    const videos = readdirSync4(dir).filter((f) => f.toLowerCase().endsWith(".mp4")).map((f) => join22(dir, f)).map((p) => ({ path: p, mtime: statSync2(p).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+    const videos = readdirSync5(dir).filter((f) => f.toLowerCase().endsWith(".mp4")).map((f) => join23(dir, f)).map((p) => ({ path: p, mtime: statSync2(p).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
     return videos[0]?.path ?? null;
   } catch {
     return null;
@@ -5831,8 +6815,8 @@ async function handleListDemos(args) {
   return withSilencedStdout(async () => {
     let entries = [];
     try {
-      entries = readdirSync4(dir).filter((f) => f.toLowerCase().endsWith(".mp4")).map((f) => {
-        const s = statSync2(join22(dir, f));
+      entries = readdirSync5(dir).filter((f) => f.toLowerCase().endsWith(".mp4")).map((f) => {
+        const s = statSync2(join23(dir, f));
         return { name: f, bytes: s.size, modified: new Date(s.mtimeMs).toISOString() };
       }).sort((a, b) => b.modified.localeCompare(a.modified));
     } catch {
@@ -5876,8 +6860,11 @@ async function handleCheckAccount() {
   });
 }
 var QUICKPEEK_HANDLERS = {
-  generate_demo: handleGenerateDemo,
-  generate_demo_from_script: handleGenerateDemoFromScript,
+  generate_demo: (args) => withDelegation("generate_demo", args, () => handleGenerateDemo(args)),
+  generate_demo_from_script: (args) => withDelegation("generate_demo_from_script", args, () => handleGenerateDemoFromScript(args)),
+  open_in_editor: handleOpenInEditor,
+  start_auth: handleStartAuth,
+  finish_auth: handleFinishAuth,
   list_demos: handleListDemos,
   get_demo_config: handleGetDemoConfig,
   list_voices: handleListVoices,
@@ -5905,5 +6892,7 @@ export {
   TOOLS,
   TOOL_HANDLERS,
   errorContent,
-  jsonContent
+  jsonContent,
+  setCanElicit,
+  setElicit
 };