@spark-apps/quickpeek 1.2.1 → 1.2.3

package/dist/mcp-tools.mjs

@@ -110,6 +110,20 @@ var init_utils = __esm({
 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) {
@@ -161,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, {
@@ -178,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 {
@@ -221,14 +254,16 @@ 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") {
+async function callAI(systemPrompt, userPrompt, tier = "free", opts = {}) {
   if (!apiKey()) {
     return {
       success: false,
@@ -238,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,
@@ -253,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) {
@@ -289,11 +324,13 @@ 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, 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`;
@@ -324,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 {
@@ -341,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",
@@ -403,7 +441,7 @@ var VERSION, CONFIG_FILE, DEFAULT_CONFIG, DEFAULT_CAPTIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
-    VERSION = "1.2.1";
+    VERSION = "1.2.3";
     CONFIG_FILE = "quickpeek.config.json";
     DEFAULT_CONFIG = {
       plan: { maxSteps: 8 },
@@ -553,7 +591,10 @@ var init_scraping = __esm({
 });
 
 // src/lib/crawl.ts
-import { chromium as chromium2 } 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":
@@ -579,7 +620,7 @@ async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
     return { title: cached.title, elements: [...cached.elements], scrollable: cached.scrollable };
   }
   const browserTask = task2("Launching browser");
-  const browser = await chromium2.launch({ headless: true });
+  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
@@ -683,9 +724,9 @@ async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
     } 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}"`;
@@ -695,7 +736,7 @@ async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
     } 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) {
@@ -782,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, "/");
@@ -796,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) => {
@@ -997,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(
@@ -1247,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;
@@ -1448,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" })
@@ -1483,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) {
@@ -1518,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 {
@@ -1540,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 {
@@ -1579,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);
@@ -1616,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) {
@@ -1626,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);
       }
@@ -1714,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;
@@ -1738,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;
@@ -1807,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");
@@ -1858,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");
@@ -1920,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,
@@ -1930,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,
@@ -1946,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,
@@ -1959,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,
@@ -1991,6 +2199,7 @@ var init_lib = __esm({
     init_crawl();
     init_cursor();
     init_ffmpeg2();
+    init_json_repair();
     init_prompts();
     init_SparkStripe_feature_gating();
     init_scraping();
@@ -2014,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);
@@ -2070,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 {
@@ -2086,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 };
@@ -2140,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;
   }
@@ -2156,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;
@@ -2264,19 +2473,16 @@ function fileResult(output, data, poster) {
 }
 
 // src/mcp/tools.ts
-import { readdirSync as readdirSync5, readFileSync as readFileSync6, statSync as statSync2 } from "fs";
+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-session.ts
-import { chromium } from "playwright";
-
 // 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;
@@ -2288,136 +2494,445 @@ 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;
 }
-async function saveAuthState(url, state) {
+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;
 }
-
-// src/browser/auth-session.ts
-var pending = null;
-function pendingSignIn() {
-  return pending?.url ?? null;
-}
-async function openSignIn(url) {
-  await cancelSignIn();
-  const browser = await chromium.launch({ headless: false });
-  const context = await browser.newContext();
-  const page = await context.newPage();
-  pending = { browser, context, url };
+function findStartUrl(url) {
+  const path = authMetaPath(url);
+  if (!path || !existsSync2(path)) return void 0;
   try {
-    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    const startUrl = JSON.parse(readFileSync2(path, "utf8")).startUrl;
+    return typeof startUrl === "string" && startUrl.startsWith("http") ? startUrl : void 0;
   } catch {
+    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;
+function resolveStartUrl(url) {
   try {
-    const path = await saveAuthState(url, await context.storageState());
-    return { host: new URL(url).host, path };
-  } finally {
-    await cancelSignIn();
+    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 cancelSignIn() {
-  const open = pending;
-  pending = null;
-  await open?.browser.close().catch(() => {
-  });
-}
-
-// src/commands/edit-cmd.ts
-import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync3 } from "fs";
-import { join as join10 } from "path";
-import chalk7 from "chalk";
 
-// src/help.ts
-init_lib();
-import chalk from "chalk";
+// src/browser/launch.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { chromium as chromium2 } from "playwright";
 
-// 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/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 {
+    const r = execSync("uname -r", { encoding: "utf-8" }).toLowerCase();
+    return r.includes("microsoft") || r.includes("wsl");
+  } catch {
+    return false;
+  }
 }
-
-// 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 tryEnableWSLInterop() {
+  return existsSync3("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
-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}`);
-    }
+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, "\\")}`;
+}
+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 {
   }
-  return lines;
+  return null;
 }
-
-// src/lib/browser-open.ts
-import { exec as exec2 } from "child_process";
-function editorBaseUrl() {
-  return (process.env.QUICKPEEK_API_BASE || "https://quickpeek.co").replace(/\/$/, "");
+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";
 }
-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());
+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);
+    });
   });
 }
-
-// src/lib/plan-validation.ts
-var INVALID_TARGETS = [
-  /\.png$/i,
+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,
@@ -2531,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();
 }
@@ -2585,10 +3103,10 @@ import chalk6 from "chalk";
 init_lib();
 
 // src/plan.ts
-import { mkdir as mkdir5, readFile as readFile3, writeFile as writeFile5 } from "fs/promises";
-import { join as join8 } from "path";
+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 chromium5 } from "playwright";
+import { chromium as chromium4 } from "playwright";
 
 // src/ai/client.ts
 init_lib();
@@ -2664,8 +3182,133 @@ async function browserLogin() {
   });
 }
 
+// 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);
+    }
+  } catch {
+  }
+}
+async function setLogFilePath(outputDir) {
+  logFilePath = join8(outputDir, LOG_FILE_NAME);
+  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
+${"=".repeat(60)}
+
+`;
+  try {
+    await mkdir5(dirname2(logFilePath), { recursive: true });
+    await writeFile5(logFilePath, header2);
+    logFileInitialized = true;
+  } catch {
+  }
+}
+async function logInfo(context, message) {
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [${context}] ${message}
+`);
+}
+async function logDebug(context, message) {
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [${context}] ${message}
+`);
+}
+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);
+  }
+  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] [${context}]
+${errorMsg}
+
+`);
+}
+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.`
+    );
+    this.name = "DelegatedGenerationError";
+    this.tool = tool;
+    this.step = step;
+    this.system = system;
+    this.prompt = prompt2;
+  }
+};
+var mcpCall = new AsyncLocalStorage();
+function runInMcpTool(tool, fn, answers = {}) {
+  return mcpCall.run({ tool, answers, pending: [] }, fn);
+}
+function currentMcpTool() {
+  return mcpCall.getStore()?.tool ?? null;
+}
+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;
 }
@@ -2713,257 +3356,123 @@ async function setupUserEmail() {
   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);
+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.error));
+    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("  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);
-    }
-    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);
-  }
-  lastRateLimitInfo = result.limits;
-  return result.content;
-}
-
-// src/browser/launch.ts
-import { mkdir as mkdir4 } from "fs/promises";
-import { chromium as chromium4 } 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 chromium3 } 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");
-  } catch {
-    return false;
-  }
-}
-function tryEnableWSLInterop() {
-  return existsSync6("/proc/sys/fs/binfmt_misc/WSLInterop");
-}
-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, "\\")}`;
-}
-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 {
-  }
-  return null;
-}
-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 = readFileSync2("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
-    if (m?.[1]) return m[1];
-  } catch {
-  }
-  return "127.0.0.1";
-}
-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 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 = 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 chromium3.connectOverCDP(`http://${windowsHost}:${proxyPort}`, { timeout: 5e3 });
-    return {
-      browser,
-      cleanup: async () => {
-        try {
-          await browser.close();
-        } catch {
-        }
-        relay.kill();
+      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)"));
       }
-    };
-  } catch (err) {
-    relay.kill();
-    throw err;
-  }
-}
-
-// 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 chromium4.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);
+    }
+    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}`));
       }
-    } else {
-      context = await chromium4.launchPersistentContext(userDataDir, {
-        headless: false,
-        args: persistentArgs,
-        viewport,
-        ...videoOpts,
-        acceptDownloads: true
-      });
+      console.log();
+      console.log(chalk4.dim(`  ${diagnose(result.status, result.host)}`));
+      console.log();
+      process.exit(1);
     }
-  } else {
-    browser = await chromium4.launch({ headless: true });
-    context = await browser.newContext({ viewport, ...videoOpts, ...authOpts, acceptDownloads: true });
+    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 = join8(workDir, ".browser-data");
-  await mkdir5(userDataDir, { recursive: true });
+  const userDataDir = join9(workDir, ".browser-data");
+  await mkdir6(userDataDir, { recursive: true });
   let context;
   let chromeSession = null;
   const useWindowsChrome = isWSL() && tryEnableWSLInterop();
-  const launchPersistent = () => chromium5.launchPersistentContext(userDataDir, {
+  const launchPersistent = () => chromium4.launchPersistentContext(userDataDir, {
     headless: false,
     args: [
       `--disable-extensions-except=${extensionPath}`,
@@ -3044,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,
@@ -3056,31 +3565,8 @@ 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", viewport) {
   const { title, elements, scrollable } = extensionPath && workDir ? { ...await crawlExtension(url, extensionPath, workDir, task2), scrollable: void 0 } : await crawlPage(url, task2, findAuthState(url), viewport);
@@ -3089,10 +3575,9 @@ async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError
   const systemPrompt = buildSystemPrompt(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,
@@ -3142,7 +3627,7 @@ async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier =
     renumberTask.fail("No valid steps");
     throw new Error("Plan has no valid steps");
   }
-  await writeFile5(planPath, JSON.stringify(plan, null, 2));
+  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`
@@ -3152,66 +3637,6 @@ async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier =
 
 // src/commands/utils/record-helpers.ts
 init_config_loader();
-
-// src/utils/logging.ts
-import { appendFile, writeFile as writeFile6 } from "fs/promises";
-import { join as join9 } from "path";
-var LOG_FILE_NAME = "quickpeek.log";
-var logFileInitialized = false;
-var logFilePath = LOG_FILE_NAME;
-async function writeLogEntry(entry) {
-  try {
-    if (!logFileInitialized) {
-      await writeFile6(logFilePath, entry);
-      logFileInitialized = true;
-    } else {
-      await appendFile(logFilePath, entry);
-    }
-  } catch {
-  }
-}
-async function setLogFilePath(outputDir) {
-  logFilePath = join9(outputDir, LOG_FILE_NAME);
-  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
-${"=".repeat(60)}
-
-`;
-  try {
-    await writeFile6(logFilePath, header2);
-    logFileInitialized = true;
-  } catch {
-  }
-}
-async function logInfo(context, message) {
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [INFO] [${context}] ${message}
-`);
-}
-async function logDebug(context, message) {
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [DEBUG] [${context}] ${message}
-`);
-}
-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);
-  }
-  await writeLogEntry(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ERROR] [${context}]
-${errorMsg}
-
-`);
-}
-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/commands/utils/record-helpers.ts
 init_utils();
 var FREE_VIDEO_LIMIT = 5;
 var INDENT2 = "   ";
@@ -3331,7 +3756,7 @@ function findPlanFile(dir, lang) {
 
 // src/commands/record-cmd.ts
 import { existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir8 } from "fs/promises";
+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();
@@ -3516,10 +3941,10 @@ 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;
@@ -3643,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;
@@ -3720,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}`);
@@ -3884,7 +4319,7 @@ import chalk12 from "chalk";
 
 // src/record.ts
 import { existsSync as existsSync13 } from "fs";
-import { mkdir as mkdir6 } from "fs/promises";
+import { mkdir as mkdir7 } from "fs/promises";
 import { join as join16 } from "path";
 import chalk11 from "chalk";
 
@@ -3895,7 +4330,7 @@ import { isAbsolute as isAbsolute2, resolve as resolve5 } from "path";
 
 // src/browser/effects.ts
 init_lib();
-import { existsSync as existsSync9, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
 import { join as join12 } from "path";
 function loadHighlightCSS() {
   const candidates = [
@@ -3905,7 +4340,7 @@ function loadHighlightCSS() {
     // src/browser/ → src/
   ];
   for (const p of candidates) {
-    if (existsSync9(p)) return readFileSync4(p, "utf-8");
+    if (existsSync9(p)) return readFileSync5(p, "utf-8");
   }
   return "";
 }
@@ -4105,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;
@@ -4910,14 +5349,14 @@ function formatStepLabel(step) {
 }
 async function recordSession(plan, config, stepDurations, workDir, baseDir, task2, logError2) {
   const videoDir = join16(workDir, "video");
-  await mkdir6(videoDir, { recursive: true });
+  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 = join16(workDir, "browser-data");
-  const recordVideo = { dir: videoDir, size: { width: config.video.width, height: config.video.height } };
+  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();
@@ -4938,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;
@@ -4964,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;
@@ -5000,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;
@@ -5022,10 +5476,11 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
       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 || !existsSync13(videoPath)) {
@@ -5195,7 +5650,7 @@ import { join as join18, resolve as resolve8 } from "path";
 init_lib();
 import { chunkWordsByCount, assTimeFromMs as formatASSTime } from "@spark-apps/video-kit";
 import { existsSync as existsSync14 } from "fs";
-import { mkdir as mkdir7, writeFile as writeFile8 } from "fs/promises";
+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 = "   ";
@@ -5288,7 +5743,7 @@ async function composeAndFinish(videoPath, audioPath, assPath, config, userTier
     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 = join17(config.output.dir, `demo${suffix}.${config.video.format}`);
   const videoDuration = await getMediaDuration(videoPath) / 1e3;
@@ -5356,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;
@@ -5460,7 +5930,7 @@ async function runVideoPhase(params) {
     const transitionTask = task("Applying transitions");
     try {
       const transitionedPath = join18(workDir, "transitioned.mp4");
-      const videoDuration = alignedStepDurations.reduce((a, b) => a + b, 0) / 1e3;
+      const videoDuration = await getMediaDuration(videoPath) / 1e3;
       await applyTransitions({
         inputVideo: videoPath,
         outputVideo: transitionedPath,
@@ -5478,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 = join18(scriptDir, "assets", "qp.wm");
-    if (!existsSync15(outroPath)) {
-      outroPath = join18(scriptDir, "..", "dist", "assets", "qp.wm");
-    }
-    if (existsSync15(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;
-      }
+  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(
@@ -5546,8 +6010,8 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
     for (const file of filesToDelete) {
       const filePath = join19(config.output.dir, file);
       if (existsSync16(filePath)) {
-        const { unlink: unlink3 } = await import("fs/promises");
-        await unlink3(filePath).catch(() => {
+        const { unlink: unlink4 } = await import("fs/promises");
+        await unlink4(filePath).catch(() => {
         });
       }
     }
@@ -5556,7 +6020,12 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
   const voice = resolveVoice(config);
   const existingMeta = await loadVoiceoverMeta(config.output.dir);
   const voiceoverFile = join19(config.output.dir, "voiceover.wav");
-  const hasExistingVoiceover = existingMeta && existsSync16(voiceoverFile);
+  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;
@@ -5613,7 +6082,7 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
 }
 
 // src/commands/utils/chrome-extension.ts
-import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync5 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync6 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join20 } from "path";
 function resolveChromeExtension(extensionId) {
@@ -5660,7 +6129,7 @@ function resolveChromeExtension(extensionId) {
       const manifestPath = join20(extPath, "manifest.json");
       if (existsSync17(manifestPath)) {
         try {
-          const manifest = JSON.parse(readFileSync5(manifestPath, "utf-8"));
+          const manifest = JSON.parse(readFileSync6(manifestPath, "utf-8"));
           if (manifest.name && !manifest.name.startsWith("__MSG_")) {
             name = manifest.name;
           }
@@ -5702,6 +6171,13 @@ async function recordCommand(url, options = {}) {
     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();
   const authResult = await runAuthPhase({
@@ -5757,7 +6233,7 @@ async function recordCommand(url, options = {}) {
   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({
@@ -5820,23 +6296,32 @@ 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}
@@ -5844,29 +6329,67 @@ 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("#"));
@@ -5875,17 +6398,39 @@ async function scriptCommand(url, scriptPath, lang) {
     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 = join22(config.output.dir, `plan-${lang ?? "en"}.json`);
-  await savePlan(plan, planPath);
-  planTask.succeed(`${plan.steps.length} steps planned`);
+  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,
@@ -5901,7 +6446,7 @@ 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(chalk16.bold.green("  Done!"));
   console.log(chalk16.cyan(`  ${finalPath}`));
@@ -5910,11 +6455,102 @@ async function scriptCommand(url, scriptPath, lang) {
 // 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;
 }
@@ -5932,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 once a session is saved for the host, by start_auth or by the user running `qp auth <url>`; it is picked up automatically. The result says whether this recording was signed in.",
+    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."
@@ -5959,16 +6607,22 @@ 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"]
     }
@@ -5984,7 +6638,7 @@ var QUICKPEEK_TOOLS = [
   },
   {
     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, so a demo can cover pages behind the login. 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.",
+    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 },
@@ -6025,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,
@@ -6039,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) {
@@ -6049,18 +6736,20 @@ 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, call start_auth with this url (or have the user run \`qp auth ${url}\`), 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) {
@@ -6071,7 +6760,7 @@ async function handleOpenInEditor(args) {
     if (!planPath) {
       return errorContent(`No plan found in ${dir}. Record the demo first with generate_demo.`);
     }
-    const parsed = parsePlanText(readFileSync6(planPath, "utf8"));
+    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);
@@ -6089,7 +6778,9 @@ 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, then confirm.`);
+    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",
@@ -6169,8 +6860,8 @@ 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,
@@ -6202,5 +6893,6 @@ export {
   TOOL_HANDLERS,
   errorContent,
   jsonContent,
+  setCanElicit,
   setElicit
 };