@spark-apps/quickpeek 1.2.0 → 1.2.2

package/dist/qp.js

@@ -59,7 +59,7 @@ function getErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function toTitleCase(text) {
-  return text.replace(/\w+/g, (word, index) => {
+  return text.replace(/\w+(?:'\w+)*/g, (word, index) => {
     if (index === 0) {
       return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
     }
@@ -125,6 +125,23 @@ var init_utils = __esm({
 });
 
 // src/lib/api-client.ts
+function apiKey() {
+  return process.env.SPARK_AI_KEY || "";
+}
+function hostOf2(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return "AI service";
+  }
+}
+function firstLine(text) {
+  return truncate((text ?? "").trim().split("\n")[0] ?? "", 200);
+}
+function truncate(text, max) {
+  const trimmed = (text ?? "").trim();
+  return trimmed.length > max ? `${trimmed.slice(0, max)}\u2026` : trimmed;
+}
 async function getOrRefreshDirectToken() {
   const now = Date.now();
   if (cachedDirectToken && cachedDirectToken.expiresAt > now + 3e5) {
@@ -133,7 +150,7 @@ async function getOrRefreshDirectToken() {
   try {
     const response = await fetch(SPARK_AI_TOKEN, {
       method: "POST",
-      headers: { "X-Api-Key": API_KEY }
+      headers: { "X-Api-Key": apiKey() }
     });
     if (!response.ok) {
       throw new Error(`Token exchange failed: ${response.status} ${response.statusText}`);
@@ -176,8 +193,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, {
@@ -193,36 +212,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((resolve9) => setTimeout(resolve9, 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 {
@@ -236,15 +272,17 @@ async function executeChat(chatUrl, bearerToken, systemPrompt, userPrompt, tier)
         }
       };
     } catch (err) {
-      if (attempt === 3) throw err;
+      if (attempt === 3) {
+        return { success: false, error: `${host} unreachable: ${getErrorMessage(err)}`, host };
+      }
       const delayMs = 1e3 * 2 ** (attempt - 1);
       await new Promise((resolve9) => setTimeout(resolve9, delayMs));
     }
   }
-  return lastRateLimitError || { success: false, error: "Request failed after retries" };
+  return lastRetriableError || { success: false, error: `${host}: request failed after retries`, host };
 }
-async function callAI(systemPrompt, userPrompt, tier = "free") {
-  if (!API_KEY) {
+async function callAI(systemPrompt, userPrompt, tier = "free", opts = {}) {
+  if (!apiKey()) {
     return {
       success: false,
       error: "AI service is not configured. Please report this issue.",
@@ -253,12 +291,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,
@@ -268,11 +306,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) {
@@ -304,18 +342,19 @@ function normalizeUrl(input) {
   url = url.replace(/^(https?:\/\/)?(www\.)?/i, "");
   return `https://${url}`;
 }
-var SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, RELAY_BASE, RELAY_TOKEN_URL, RELAY_CHAT_URL, API_KEY, cachedDirectToken, cachedRelayToken;
+var SERVER_BACKOFF_MS, CLI_BACKOFF_MS, SPARK_AI_BASE, SPARK_AI_CHAT, SPARK_AI_TOKEN, RELAY_BASE, RELAY_TOKEN_URL, RELAY_CHAT_URL, cachedDirectToken, cachedRelayToken;
 var init_api_client = __esm({
   "src/lib/api-client.ts"() {
     "use strict";
     init_utils();
+    SERVER_BACKOFF_MS = [2e3, 4e3];
+    CLI_BACKOFF_MS = [1e4, 3e4];
     SPARK_AI_BASE = "https://sparkbrain.app";
     SPARK_AI_CHAT = `${SPARK_AI_BASE}/api/chat`;
     SPARK_AI_TOKEN = `${SPARK_AI_BASE}/api/models/token`;
     RELAY_BASE = process.env.QUICKPEEK_API_BASE || "https://quickpeek.co";
     RELAY_TOKEN_URL = `${RELAY_BASE}/api/cli/token`;
     RELAY_CHAT_URL = `${RELAY_BASE}/api/cli/ai`;
-    API_KEY = process.env.SPARK_AI_KEY || "";
     cachedDirectToken = null;
     cachedRelayToken = null;
   }
@@ -340,7 +379,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 {
@@ -357,17 +396,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",
@@ -419,7 +459,7 @@ var VERSION, CONFIG_FILE, DEFAULT_CONFIG, DEFAULT_CAPTIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
-    VERSION = "1.1.1";
+    VERSION = "1.2.1";
     CONFIG_FILE = "quickpeek.config.json";
     DEFAULT_CONFIG = {
       plan: { maxSteps: 8 },
@@ -569,6 +609,9 @@ var init_scraping = __esm({
 });
 
 // src/lib/crawl.ts
+function idSelector(id) {
+  return /^[A-Za-z_-][\w-]*$/.test(id) ? `#${id}` : `[id="${id.replace(/(["\\])/g, "\\$1")}"]`;
+}
 function getActionForType(type) {
   switch (type) {
     case "button":
@@ -586,20 +629,29 @@ function getActionForType(type) {
       return "type";
   }
 }
-async function crawlPage(url, task2 = noopTask, storageStatePath) {
-  const cached = crawlCache.get(url);
+async function crawlPage(url, task2 = noopTask, storageStatePath, viewport) {
+  const cacheKey = viewport ? `${url}@${viewport.width}x${viewport.height}` : url;
+  const cached = crawlCache.get(cacheKey);
   if (cached && Date.now() - cached.timestamp < CRAWL_CACHE_TTL_MS) {
     task2("Using cached crawl").succeed(`Found ${cached.elements.length} interactive elements (cached)`);
-    return { title: cached.title, elements: [...cached.elements] };
+    return { title: cached.title, elements: [...cached.elements], scrollable: cached.scrollable };
   }
   const browserTask = task2("Launching browser");
-  const browser = await import_playwright.chromium.launch({ headless: true });
-  const context = await browser.newContext(storageStatePath ? { storageState: storageStatePath } : {});
+  const browser = await import_playwright3.chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    ...storageStatePath ? { storageState: storageStatePath } : {},
+    // Crawl at the size we will record at, or the measurements below describe
+    // a page nobody will ever see.
+    ...viewport ? { viewport } : {}
+  });
   const page = await context.newPage();
   browserTask.succeed(storageStatePath ? "Browser launched (signed in)" : "Browser launched");
   const crawlTask = task2("Crawling page");
   await page.goto(url, { waitUntil: "networkidle", timeout: 3e4 });
   const title = await page.title();
+  const scrollable = await page.evaluate(
+    "Math.max(0, document.documentElement.scrollHeight - window.innerHeight)"
+  );
   const rawElements = await page.evaluate(`
     (() => {
       const items = [];
@@ -689,9 +741,9 @@ async function crawlPage(url, task2 = noopTask, storageStatePath) {
     } else if (el.isFile || el.type === "file") {
       selector = 'input[type="file"]';
     } else if (el.type === "range") {
-      selector = el.id ? `#${el.id}` : 'input[type="range"]';
+      selector = el.id ? idSelector(el.id) : 'input[type="range"]';
     } else if (el.type === "checkbox") {
-      selector = el.id ? `#${el.id}` : 'input[type="checkbox"]';
+      selector = el.id ? idSelector(el.id) : 'input[type="checkbox"]';
     } else if (el.type === "button") {
       if (btnTexts[el.text] === 1) {
         selector = `text="${el.text}"`;
@@ -701,7 +753,7 @@ async function crawlPage(url, task2 = noopTask, storageStatePath) {
     } else if (el.type === "link") {
       selector = `text="${el.text}"`;
     } else if (el.id) {
-      selector = `#${el.id}`;
+      selector = idSelector(el.id);
     } else if (el.name) {
       selector = `[name="${el.name}"]`;
     } else if (el.placeholder) {
@@ -729,18 +781,18 @@ async function crawlPage(url, task2 = noopTask, storageStatePath) {
   });
   await browser.close();
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
-  crawlCache.set(url, { timestamp: Date.now(), title, elements: [...elements] });
+  crawlCache.set(cacheKey, { timestamp: Date.now(), title, elements: [...elements], scrollable });
   if (crawlCache.size > CRAWL_CACHE_MAX_ENTRIES) {
     const oldest = crawlCache.keys().next().value;
     if (oldest !== void 0) crawlCache.delete(oldest);
   }
-  return { title, elements };
+  return { title, elements, scrollable };
 }
-var import_playwright, noopTask, CRAWL_CACHE_TTL_MS, CRAWL_CACHE_MAX_ENTRIES, crawlCache;
+var import_playwright3, noopTask, CRAWL_CACHE_TTL_MS, CRAWL_CACHE_MAX_ENTRIES, crawlCache;
 var init_crawl = __esm({
   "src/lib/crawl.ts"() {
     "use strict";
-    import_playwright = require("playwright");
+    import_playwright3 = require("playwright");
     init_scraping();
     noopTask = () => ({ succeed: () => {
     } });
@@ -802,9 +854,9 @@ function convertArgToWSL(arg2) {
 function spawnFFmpeg(cmd2, args) {
   if (isWindowsRuntime) {
     const wslArgs = args.map(convertArgToWSL);
-    return (0, import_node_child_process.spawn)("wsl", ["-e", cmd2, ...wslArgs]);
+    return (0, import_node_child_process2.spawn)("wsl", ["-e", cmd2, ...wslArgs]);
   }
-  return (0, import_node_child_process.spawn)(cmd2, args);
+  return (0, import_node_child_process2.spawn)(cmd2, args);
 }
 function runFFmpeg(args, errorLabel) {
   return new Promise((resolve9, reject) => {
@@ -820,11 +872,11 @@ function runFFmpeg(args, errorLabel) {
     proc.on("error", reject);
   });
 }
-var import_node_child_process, isWindowsRuntime;
+var import_node_child_process2, isWindowsRuntime;
 var init_spawn = __esm({
   "src/lib/ffmpeg/spawn.ts"() {
     "use strict";
-    import_node_child_process = require("child_process");
+    import_node_child_process2 = require("child_process");
     init_utils();
     isWindowsRuntime = process.platform === "win32";
   }
@@ -1005,8 +1057,39 @@ function getMediaDuration(filePath) {
     proc.on("error", reject);
   });
 }
+function getAudioCodec(filePath) {
+  return new Promise((resolve9) => {
+    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) => resolve9(code === 0 ? stdout.trim() : ""));
+    proc.on("error", () => resolve9(""));
+  });
+}
+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(
@@ -1255,6 +1338,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;
@@ -1308,7 +1499,7 @@ EXAMPLES:
 \u2022 File upload: "target": "input[type=\\"file\\"]"
 \u2022 Slider: "target": "input[type=\\"range\\"]"`;
 }
-function buildUserPrompt(url, title, elements, langName, description, maxSteps) {
+function buildUserPrompt(url, title, elements, langName, description, maxSteps, scrollable) {
   const lang = langName ? `
 Language: Write ALL captions in ${langName}.` : "";
   const purpose = description ? `
@@ -1346,8 +1537,13 @@ ${selectables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`
 ${checkables.map((e) => `\u2022 "${e.text}" \u2192 ${e.selector}`).join("\n")}`);
   }
   const elementSummary = elementDict.length > 0 ? elementDict.join("\n\n") : "(no interactive elements found)";
+  const cannotScroll = scrollable !== void 0 && scrollable < MIN_USEFUL_SCROLL_PX;
+  const scrolling = cannotScroll ? `
+
+SCROLLING: this page has only ${scrollable}px of scroll travel at the recording size, so it does not scroll.` : "";
+  const scrollRule = cannotScroll ? "\n\u2022 NEVER use the scroll action: this page does not scroll, so the video would freeze. Use wait and click steps only" : "";
   return `URL: ${url}
-Title: ${title}${purpose}
+Title: ${title}${purpose}${scrolling}
 
 AVAILABLE ELEMENTS (grouped by action):
 ${elementSummary}
@@ -1357,7 +1553,7 @@ REQUIREMENTS:
 \u2022 Complete ONE user journey: input \u2192 process \u2192 output
 \u2022 For CLICK: use simplified text target like "extract frame" or "download"
 \u2022 For UPLOAD/DRAG/TYPE: use the CSS selector shown above
-\u2022 For buttons that appear after actions: use partial text like "extract" or "download"${lang}
+\u2022 For buttons that appear after actions: use partial text like "extract" or "download"${scrollRule}${lang}
 
 Return JSON:
 {
@@ -1380,10 +1576,12 @@ TARGET SYNTAX:
 \u2022 Sliders: input[type="range"]
 \u2022 Text inputs: Use selector from list above`;
 }
+var MIN_USEFUL_SCROLL_PX;
 var init_prompts = __esm({
   "src/lib/prompts.ts"() {
     "use strict";
     init_utils();
+    MIN_USEFUL_SCROLL_PX = 200;
   }
 });
 
@@ -1449,7 +1647,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" })
@@ -1516,7 +1714,7 @@ async function getMediaStepDuration(step, baseDir) {
     return 0;
   }
   const mediaPath = (0, import_node_path2.isAbsolute)(step.value) ? step.value : (0, import_node_path2.resolve)(baseDir, step.value);
-  if (!(0, import_node_fs2.existsSync)(mediaPath)) {
+  if (!(0, import_node_fs3.existsSync)(mediaPath)) {
     return 0;
   }
   try {
@@ -1538,8 +1736,8 @@ async function getMediaStepDuration(step, baseDir) {
 async function loadVoiceoverMeta(outputDir) {
   const metaPath = (0, import_node_path2.join)(outputDir, "voiceover.json");
   try {
-    if (!(0, import_node_fs2.existsSync)(metaPath)) return null;
-    const content = await (0, import_promises2.readFile)(metaPath, "utf-8");
+    if (!(0, import_node_fs3.existsSync)(metaPath)) return null;
+    const content = await (0, import_promises3.readFile)(metaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -1547,7 +1745,7 @@ async function loadVoiceoverMeta(outputDir) {
 }
 async function saveVoiceoverMeta(outputDir, meta) {
   const metaPath = (0, import_node_path2.join)(outputDir, "voiceover.json");
-  await (0, import_promises2.writeFile)(metaPath, JSON.stringify(meta, null, 2));
+  await (0, import_promises3.writeFile)(metaPath, JSON.stringify(meta, null, 2));
 }
 async function concatenateAudio(inputs, output, workDir) {
   const formatPath = (f) => {
@@ -1556,17 +1754,17 @@ async function concatenateAudio(inputs, output, workDir) {
   };
   const listContent = inputs.map((f) => `file '${formatPath(f)}'`).join("\n");
   const listPath = (0, import_node_path2.join)(workDir, "concat.txt");
-  await (0, import_promises2.writeFile)(listPath, listContent);
+  await (0, import_promises3.writeFile)(listPath, listContent);
   await concatMedia(listPath, output);
-  await (0, import_promises2.unlink)(listPath).catch(() => {
+  await (0, import_promises3.unlink)(listPath).catch(() => {
   });
 }
-var import_node_fs2, import_promises2, import_node_path2, isWindows;
+var import_node_fs3, import_promises3, import_node_path2, isWindows;
 var init_helpers = __esm({
   "src/lib/tts/helpers.ts"() {
     "use strict";
-    import_node_fs2 = require("fs");
-    import_promises2 = require("fs/promises");
+    import_node_fs3 = require("fs");
+    import_promises3 = require("fs/promises");
     import_node_path2 = require("path");
     init_ffmpeg2();
     init_utils();
@@ -1615,9 +1813,9 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
     const audioPath = (0, import_node_path3.join)(audioDir, `step-${stepNum}.mp3`);
     const originalPaddingPath = (0, import_node_path3.join)(audioDir, `step-${stepNum}-padding.mp3`);
     const silencePath = (0, import_node_path3.join)(audioDir, `step-${stepNum}-silence.mp3`);
-    if ((0, import_node_fs3.existsSync)(audioPath)) {
+    if ((0, import_node_fs4.existsSync)(audioPath)) {
       segments.push(audioPath);
-      if ((0, import_node_fs3.existsSync)(originalPaddingPath)) {
+      if ((0, import_node_fs4.existsSync)(originalPaddingPath)) {
         segments.push(originalPaddingPath);
       }
       if (recordingDuration > voiceDuration) {
@@ -1625,7 +1823,7 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
         await generateSilence(alignPaddingPath, recordingDuration - voiceDuration);
         segments.push(alignPaddingPath);
       }
-    } else if ((0, import_node_fs3.existsSync)(silencePath)) {
+    } else if ((0, import_node_fs4.existsSync)(silencePath)) {
       if (targetDuration !== voiceDuration) {
         await generateSilence(silencePath, targetDuration);
       }
@@ -1649,11 +1847,11 @@ async function alignVoiceoverToRecording(stepAudio, actualRecordingDurations, wo
   }
   return alignedStepAudio;
 }
-var import_node_fs3, import_node_path3;
+var import_node_fs4, import_node_path3;
 var init_timing = __esm({
   "src/lib/tts/timing.ts"() {
     "use strict";
-    import_node_fs3 = require("fs");
+    import_node_fs4 = require("fs");
     import_node_path3 = require("path");
     init_ffmpeg2();
     init_helpers();
@@ -1718,6 +1916,19 @@ var init_voices = __esm({
 
 // src/lib/tts/synthesize.ts
 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 = (0, import_node_path5.join)((0, import_node_path5.resolve)(outputPath, ".."), `tts-${Date.now()}.py`);
   const wslScriptPath = isWindows ? toWSLPathForTTS((0, import_node_path5.resolve)(tempScriptPath)) : tempScriptPath;
   const wslOutputPath = isWindows ? toWSLPathForTTS((0, import_node_path5.resolve)(outputPath)) : outputPath;
@@ -1735,44 +1946,49 @@ async def main():
 asyncio.run(main())
 `;
   try {
-    await (0, import_promises3.writeFile)(tempScriptPath, pythonScript);
+    await (0, import_promises4.writeFile)(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 (0, import_promises4.unlink)(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 (0, import_promises5.pipeline)(audioStream, (0, import_node_fs5.createWriteStream)(outputPath));
+      const { size } = await (0, import_promises4.stat)(outputPath);
+      if (size === 0) throw new Error("No audio data received");
+      return;
+    } catch (nodeErr) {
+      await (0, import_promises4.unlink)(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 import_node_child_process2, import_promises3, import_node_path5, import_node_util, execAsync;
+var import_node_child_process3, import_node_fs5, import_promises4, import_node_path5, import_promises5, import_node_util, execAsync, PYTHON_ATTEMPTS;
 var init_synthesize = __esm({
   "src/lib/tts/synthesize.ts"() {
     "use strict";
-    import_node_child_process2 = require("child_process");
-    import_promises3 = require("fs/promises");
+    import_node_child_process3 = require("child_process");
+    import_node_fs5 = require("fs");
+    import_promises4 = require("fs/promises");
     import_node_path5 = require("path");
+    import_promises5 = require("stream/promises");
     import_node_util = require("util");
     init_helpers();
-    execAsync = (0, import_node_util.promisify)(import_node_child_process2.exec);
+    execAsync = (0, import_node_util.promisify)(import_node_child_process3.exec);
+    PYTHON_ATTEMPTS = 2;
   }
 });
 
@@ -1809,7 +2025,7 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     return { voiceoverPath: "", stepAudio: stepAudio2 };
   }
   const audioDir = (0, import_node_path6.join)(workDir, "audio");
-  await (0, import_promises4.mkdir)(audioDir, { recursive: true });
+  await (0, import_promises6.mkdir)(audioDir, { recursive: true });
   const segments = [];
   const stepAudio = /* @__PURE__ */ new Map();
   const ttsTask = task2("Generating voiceover");
@@ -1860,7 +2076,7 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
     return { voiceoverPath: "", stepAudio };
   }
   const concatTask = task2("Combining audio");
-  await (0, import_promises4.mkdir)(outputDir, { recursive: true });
+  await (0, import_promises6.mkdir)(outputDir, { recursive: true });
   const voiceoverPath = (0, import_node_path6.join)(outputDir, "voiceover.wav");
   await concatenateAudio(segments, voiceoverPath, workDir);
   concatTask.succeed("Done");
@@ -1874,11 +2090,11 @@ async function generateVoiceover(steps, config, workDir, outputDir, logError2, t
   await saveVoiceoverMeta(outputDir, meta);
   return { voiceoverPath, stepAudio };
 }
-var import_promises4, import_node_path6;
+var import_promises6, import_node_path6;
 var init_generate = __esm({
   "src/lib/tts/generate.ts"() {
     "use strict";
-    import_promises4 = require("fs/promises");
+    import_promises6 = require("fs/promises");
     import_node_path6 = require("path");
     init_ffmpeg2();
     init_voices();
@@ -1925,6 +2141,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,
@@ -1935,9 +2152,11 @@ __export(lib_exports, {
   FEATURES: () => FEATURES,
   INTERACTIVE_SELECTORS: () => INTERACTIVE_SELECTORS,
   LANGUAGE_VOICES: () => import_video_kit5.WIDE_VOICES,
+  SERVER_BACKOFF_MS: () => SERVER_BACKOFF_MS,
   VERSION: () => VERSION,
   alignVoiceoverToRecording: () => alignVoiceoverToRecording,
   applyTransitions: () => applyTransitions,
+  buildConcatArgs: () => buildConcatArgs,
   buildKeepSegments: () => buildKeepSegments,
   buildStepTransitions: () => buildStepTransitions,
   buildSystemPrompt: () => buildSystemPrompt,
@@ -1951,9 +2170,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,
@@ -1964,20 +2185,25 @@ __export(lib_exports, {
   hasAccess: () => hasAccess,
   hasTrialRemaining: () => hasTrialRemaining,
   hexToASS: () => import_video_kit.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,
@@ -1996,6 +2222,7 @@ var init_lib = __esm({
     init_crawl();
     init_cursor();
     init_ffmpeg2();
+    init_json_repair();
     init_prompts();
     init_SparkStripe_feature_gating();
     init_scraping();
@@ -2011,19 +2238,17 @@ var init_lib = __esm({
 
 // src/qp.ts
 var import_dotenv = __toESM(require("dotenv"));
-var import_chalk20 = __toESM(require("chalk"));
+var import_chalk21 = __toESM(require("chalk"));
 
 // src/commands/auth-cmd.ts
-var import_node_readline2 = require("readline");
 var import_chalk3 = __toESM(require("chalk"));
-var import_playwright2 = require("playwright");
 
 // src/browser/auth-state.ts
 var import_node_fs = require("fs");
 var import_promises = require("fs/promises");
 var import_node_os = require("os");
 var import_node_path = require("path");
-var AUTH_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".quickpeek", "auth");
+var AUTH_DIR = process.env.QUICKPEEK_AUTH_DIR || (0, import_node_path.join)((0, import_node_os.homedir)(), ".quickpeek", "auth");
 function hostOf(url) {
   try {
     return new URL(url).host;
@@ -2035,150 +2260,462 @@ function authStatePath(url) {
   const host = hostOf(url);
   return host ? (0, import_node_path.join)(AUTH_DIR, `${host}.json`) : null;
 }
+function authMetaPath(url) {
+  const host = hostOf(url);
+  return host ? (0, import_node_path.join)(AUTH_DIR, `${host}.meta.json`) : null;
+}
 function findAuthState(url) {
   const path = authStatePath(url);
   return path && (0, import_node_fs.existsSync)(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 (0, import_promises.mkdir)(AUTH_DIR, { recursive: true });
   await (0, import_promises.writeFile)(path, JSON.stringify(state, null, 2));
   await (0, import_promises.chmod)(path, 384);
+  if (startUrl) {
+    await (0, import_promises.writeFile)(authMetaPath(url), JSON.stringify({ startUrl, savedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+  }
   return path;
 }
+function findStartUrl(url) {
+  const path = authMetaPath(url);
+  if (!path || !(0, import_node_fs.existsSync)(path)) return void 0;
+  try {
+    const startUrl = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8")).startUrl;
+    return typeof startUrl === "string" && startUrl.startsWith("http") ? startUrl : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveStartUrl(url) {
+  try {
+    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 clearAuthState(url) {
   if (url) {
     const path = authStatePath(url);
     if (!path || !(0, import_node_fs.existsSync)(path)) return [];
     await (0, import_promises.unlink)(path);
+    const meta = authMetaPath(url);
+    if (meta && (0, import_node_fs.existsSync)(meta)) await (0, import_promises.unlink)(meta);
     return [hostOf(url)];
   }
   if (!(0, import_node_fs.existsSync)(AUTH_DIR)) return [];
   const files = (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json"));
   await Promise.all(files.map((f) => (0, import_promises.unlink)((0, import_node_path.join)(AUTH_DIR, f))));
-  return files.map((f) => f.slice(0, -".json".length));
+  return files.filter((f) => !f.endsWith(".meta.json")).map((f) => f.slice(0, -".json".length));
 }
 async function listAuthStates() {
   if (!(0, import_node_fs.existsSync)(AUTH_DIR)) return [];
-  return (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -".json".length));
+  return (await (0, import_promises.readdir)(AUTH_DIR)).filter((f) => f.endsWith(".json") && !f.endsWith(".meta.json")).map((f) => f.slice(0, -".json".length));
 }
 
-// src/help.ts
-var import_chalk = __toESM(require("chalk"));
-init_lib();
-
-// src/logo.ts
-var import_figlet = __toESM(require("figlet"));
-var import_gradient_string = __toESM(require("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 = import_figlet.default.textSync(resolved.text, {
-    font: resolved.font,
-    horizontalLayout: resolved.horizontalLayout
-  });
-  const colored = (0, import_gradient_string.default)(resolved.gradientColors)(ascii);
-  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
-}
+// src/browser/launch.ts
+var import_promises2 = require("fs/promises");
+var import_playwright2 = require("playwright");
 
-// src/utils/config-loader.ts
-var import_node_fs4 = require("fs");
-var import_promises5 = require("fs/promises");
-var import_node_os2 = require("os");
-var import_node_path7 = require("path");
-init_lib();
-async function loadConfig(_url, langOverride) {
-  const configPath = (0, import_node_path7.join)(process.cwd(), CONFIG_FILE);
-  if ((0, import_node_fs4.existsSync)(configPath)) {
-    try {
-      const content = await (0, import_promises5.readFile)(configPath, "utf-8");
-      const userConfig = JSON.parse(content);
-      const config = {
-        lang: langOverride || userConfig.lang || "en",
-        plan: { ...DEFAULT_CONFIG.plan, ...userConfig.plan },
-        video: { ...DEFAULT_CONFIG.video, ...userConfig.video },
-        audio: { ...DEFAULT_CONFIG.audio, ...userConfig.audio },
-        music: userConfig.music,
-        timing: { ...DEFAULT_CONFIG.timing, ...userConfig.timing },
-        output: { ...DEFAULT_CONFIG.output, ...userConfig.output }
-      };
-      return { config, created: false };
-    } catch {
-    }
+// src/browser/wsl.ts
+var import_node_child_process = require("child_process");
+var import_node_fs2 = require("fs");
+var import_node_http = require("http");
+var import_playwright = require("playwright");
+function isWSL() {
+  if (process.platform !== "linux") return false;
+  try {
+    const r = (0, import_node_child_process.execSync)("uname -r", { encoding: "utf-8" }).toLowerCase();
+    return r.includes("microsoft") || r.includes("wsl");
+  } catch {
+    return false;
   }
-  const fullDefaultConfig = {
-    lang: "en",
-    plan: { maxSteps: 8 },
-    video: {
-      width: 1080,
-      height: 1920,
-      fps: 30,
-      quality: 0.5,
-      preset: "fast",
-      cursor: true,
-      highlight: false,
-      fadeIn: 500,
-      // ms
-      fadeOut: 500,
-      // ms
-      contrast: 0.25
-    },
-    audio: {
-      // Voice is derived from lang setting via LANGUAGE_VOICES mapping
-      // To override, use Edge TTS voice name like 'en-GB-SoniaNeural'
-      speed: 1
-    },
-    music: {
-      path: "",
-      volume: 0.3
-    },
-    output: { dir: "./demo" }
-  };
-  await (0, import_promises5.writeFile)(configPath, JSON.stringify(fullDefaultConfig, null, 2));
-  return { config: { ...DEFAULT_CONFIG, lang: langOverride || "en" }, created: true };
 }
-var WORK_DIR = ".quickpeek";
-async function prepareWorkDir() {
-  const workDir = (0, import_node_path7.join)(process.cwd(), WORK_DIR);
-  if ((0, import_node_fs4.existsSync)(workDir)) {
-    await (0, import_promises5.rm)(workDir, { recursive: true });
-  }
-  await (0, import_promises5.mkdir)(workDir, { recursive: true });
-  return workDir;
+function tryEnableWSLInterop() {
+  return (0, import_node_fs2.existsSync)("/proc/sys/fs/binfmt_misc/WSLInterop");
 }
-var USER_DATA_DIR = (0, import_node_path7.join)((0, import_node_os2.homedir)(), ".quickpeek");
-var USER_DATA_FILE = (0, import_node_path7.join)(USER_DATA_DIR, "user.json");
-async function loadUserData() {
+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 ((0, import_node_fs2.existsSync)(p)) return p;
   try {
-    if ((0, import_node_fs4.existsSync)(USER_DATA_FILE)) {
-      return JSON.parse(await (0, import_promises5.readFile)(USER_DATA_FILE, "utf-8"));
-    }
+    const line = (0, import_node_child_process.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 {};
+  return null;
 }
-async function saveUserData(userData) {
-  if (!(0, import_node_fs4.existsSync)(USER_DATA_DIR)) {
-    await (0, import_promises5.mkdir)(USER_DATA_DIR, { recursive: true });
+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 = (0, import_node_child_process.execSync)("ip route show default", { encoding: "utf-8", timeout: 2e3 }).match(
+      /default via (\d+\.\d+\.\d+\.\d+)/
+    );
+    if (m?.[1]) return m[1];
+  } catch {
   }
-  const existing = await loadUserData();
-  const merged = { ...existing, ...userData };
-  await (0, import_promises5.writeFile)(USER_DATA_FILE, JSON.stringify(merged, null, 2));
+  try {
+    const m = (0, import_node_fs2.readFileSync)("/etc/resolv.conf", "utf-8").match(/nameserver\s+(\d+\.\d+\.\d+\.\d+)/);
+    if (m?.[1]) return m[1];
+  } catch {
+  }
+  return "127.0.0.1";
 }
-var DEFAULT_CAPTIONS_CSS = `.caption {
-  font-family: Arial, sans-serif;
-  -webkit-text-stroke: 3px #000000;
+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((resolve9, reject) => {
+    const proc = (0, import_node_child_process.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);
+        resolve9({ proc, port: +m[1] });
+      }
+    });
+    proc.on("error", (e) => {
+      clearTimeout(timer);
+      reject(e);
+    });
+  });
 }
-.caption .regular {
-  font-size: 56px;
-  color: #FFFFFF;
+function waitForChrome(host, port) {
+  return new Promise((resolve9, 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 = (0, import_node_http.request)({ host, port, path: "/json/version", method: "GET" }, (res) => {
+        res.resume();
+        resolve9();
+      });
+      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 = (0, import_node_child_process.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 import_playwright.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 (0, import_promises2.mkdir)(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 import_playwright2.chromium.launchPersistentContext(userDataDir, {
+          headless: false,
+          args: persistentArgs,
+          viewport,
+          ...scaleOpts,
+          ...videoOpts,
+          ...cspOpts,
+          acceptDownloads: true
+        });
+      }
+    } else {
+      context = await import_playwright2.chromium.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 import_playwright2.chromium.launch({ ...headedOpts, channel: "chrome" });
+      } catch {
+        browser = await import_playwright2.chromium.launch(headedOpts);
+      }
+    } else {
+      browser = await import_playwright2.chromium.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 import_playwright2.chromium.launch({ ...opts, channel: "chrome" });
+  } catch {
+    return await import_playwright2.chromium.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
+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;
+}
+
+// src/help.ts
+var import_chalk = __toESM(require("chalk"));
+init_lib();
+
+// src/logo.ts
+var import_figlet = __toESM(require("figlet"));
+var import_gradient_string = __toESM(require("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 = import_figlet.default.textSync(resolved.text, {
+    font: resolved.font,
+    horizontalLayout: resolved.horizontalLayout
+  });
+  const colored = (0, import_gradient_string.default)(resolved.gradientColors)(ascii);
+  return resolved.suffix ? `${colored}${resolved.suffix}` : colored;
+}
+
+// src/utils/config-loader.ts
+var import_node_fs6 = require("fs");
+var import_promises7 = require("fs/promises");
+var import_node_os2 = require("os");
+var import_node_path7 = require("path");
+init_lib();
+async function loadConfig(_url, langOverride) {
+  const configPath = (0, import_node_path7.join)(process.cwd(), CONFIG_FILE);
+  if ((0, import_node_fs6.existsSync)(configPath)) {
+    try {
+      const content = await (0, import_promises7.readFile)(configPath, "utf-8");
+      const userConfig = JSON.parse(content);
+      const config = {
+        lang: langOverride || userConfig.lang || "en",
+        plan: { ...DEFAULT_CONFIG.plan, ...userConfig.plan },
+        video: { ...DEFAULT_CONFIG.video, ...userConfig.video },
+        audio: { ...DEFAULT_CONFIG.audio, ...userConfig.audio },
+        music: userConfig.music,
+        timing: { ...DEFAULT_CONFIG.timing, ...userConfig.timing },
+        output: { ...DEFAULT_CONFIG.output, ...userConfig.output }
+      };
+      return { config, created: false };
+    } catch {
+    }
+  }
+  const fullDefaultConfig = {
+    lang: "en",
+    plan: { maxSteps: 8 },
+    video: {
+      width: 1080,
+      height: 1920,
+      fps: 30,
+      quality: 0.5,
+      preset: "fast",
+      cursor: true,
+      highlight: false,
+      fadeIn: 500,
+      // ms
+      fadeOut: 500,
+      // ms
+      contrast: 0.25
+    },
+    audio: {
+      // Voice is derived from lang setting via LANGUAGE_VOICES mapping
+      // To override, use Edge TTS voice name like 'en-GB-SoniaNeural'
+      speed: 1
+    },
+    music: {
+      path: "",
+      volume: 0.3
+    },
+    output: { dir: "./demo" }
+  };
+  await (0, import_promises7.writeFile)(configPath, JSON.stringify(fullDefaultConfig, null, 2));
+  return { config: { ...DEFAULT_CONFIG, lang: langOverride || "en" }, created: true };
+}
+var WORK_DIR = ".quickpeek";
+async function prepareWorkDir() {
+  const workDir = (0, import_node_path7.join)(process.cwd(), WORK_DIR);
+  if ((0, import_node_fs6.existsSync)(workDir)) {
+    await (0, import_promises7.rm)(workDir, { recursive: true });
+  }
+  await (0, import_promises7.mkdir)(workDir, { recursive: true });
+  return workDir;
+}
+var USER_DATA_DIR = (0, import_node_path7.join)((0, import_node_os2.homedir)(), ".quickpeek");
+var USER_DATA_FILE = (0, import_node_path7.join)(USER_DATA_DIR, "user.json");
+async function loadUserData() {
+  try {
+    if ((0, import_node_fs6.existsSync)(USER_DATA_FILE)) {
+      return JSON.parse(await (0, import_promises7.readFile)(USER_DATA_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return {};
+}
+async function saveUserData(userData) {
+  if (!(0, import_node_fs6.existsSync)(USER_DATA_DIR)) {
+    await (0, import_promises7.mkdir)(USER_DATA_DIR, { recursive: true });
+  }
+  const existing = await loadUserData();
+  const merged = { ...existing, ...userData };
+  await (0, import_promises7.writeFile)(USER_DATA_FILE, JSON.stringify(merged, null, 2));
+}
+var DEFAULT_CAPTIONS_CSS = `.caption {
+  font-family: Arial, sans-serif;
+  -webkit-text-stroke: 3px #000000;
+}
+.caption .regular {
+  font-size: 56px;
+  color: #FFFFFF;
 }
 .caption .highlight {
   font-size: 64px;
@@ -2232,12 +2769,12 @@ function parseCaptionCSS(css) {
 }
 async function loadCaptions() {
   const captionsPath = (0, import_node_path7.join)(process.cwd(), "captions.css");
-  if (!(0, import_node_fs4.existsSync)(captionsPath)) {
-    await (0, import_promises5.writeFile)(captionsPath, DEFAULT_CAPTIONS_CSS);
+  if (!(0, import_node_fs6.existsSync)(captionsPath)) {
+    await (0, import_promises7.writeFile)(captionsPath, DEFAULT_CAPTIONS_CSS);
     return DEFAULT_CAPTIONS;
   }
   try {
-    const css = await (0, import_promises5.readFile)(captionsPath, "utf-8");
+    const css = await (0, import_promises7.readFile)(captionsPath, "utf-8");
     return parseCaptionCSS(css);
   } catch {
     return DEFAULT_CAPTIONS;
@@ -2248,8 +2785,8 @@ async function savePlan(plan, planPath) {
     ...plan,
     steps: plan.steps.map(({ duration, ...step }) => step)
   };
-  await (0, import_promises5.mkdir)((0, import_node_path7.dirname)(planPath), { recursive: true });
-  await (0, import_promises5.writeFile)(planPath, JSON.stringify(cleanPlan, null, 2));
+  await (0, import_promises7.mkdir)((0, import_node_path7.dirname)(planPath), { recursive: true });
+  await (0, import_promises7.writeFile)(planPath, JSON.stringify(cleanPlan, null, 2));
 }
 
 // src/help.ts
@@ -2324,9 +2861,11 @@ async function showHelp() {
       "Use your own narration script"
     ],
     [`${cmd("qp capture")} ${arg("<url>")}`, `qp capture <url>`, "Record interactions manually"],
+    [`${cmd("qp edit")} ${arg("<url>")}`, `qp edit <url>`, "Edit the demo plan in the browser"],
     [`${cmd("qp login")}`, `qp login`, "Sign in with your Google account"],
     [`${cmd("qp logout")}`, `qp logout`, "Sign out"],
     [`${cmd("qp auth")} ${arg("<url>")}`, `qp auth <url>`, "Save a signed-in session for a site you demo"],
+    [`${cmd("qp auth list")}`, `qp auth list`, "Show which sites have a saved session"],
     [`${cmd("qp auth clear")} ${arg("[url]")}`, `qp auth clear [url]`, "Forget saved sessions"],
     [`${cmd("qp init")}`, `qp init`, "Create config file"],
     [`${cmd("qp config")} ${arg("<key>")} ${arg("<value>")}`, `qp config <key> <value>`, "Update a config option"]
@@ -2381,6 +2920,9 @@ var autoYes = false;
 function setAutoYes(value) {
   autoYes = value;
 }
+function isAutoYes() {
+  return autoYes;
+}
 function task(text) {
   return (0, import_ora.default)({ text, prefixText: INDENT, spinner: "dots" }).start();
 }
@@ -2411,10 +2953,19 @@ function promptInput(prompt2) {
     });
   });
 }
+function waitForEnter(prompt2 = `${INDENT}Press Enter when done...`) {
+  return new Promise((resolve9) => {
+    const rl = (0, import_node_readline.createInterface)({ input: process.stdin, output: process.stdout });
+    rl.question(prompt2, () => {
+      rl.close();
+      resolve9();
+    });
+  });
+}
 var _isWSL = process.platform === "linux" && process.env.WSL_DISTRO_NAME;
 function formatClickablePath(filePath) {
   const absolutePath = (0, import_node_path8.resolve)(filePath);
-  if (_isWSL) {
+  if (_isWSL || process.platform !== "win32") {
     return absolutePath;
   }
   let formatted = absolutePath;
@@ -2431,15 +2982,6 @@ function formatDuration(ms) {
 }
 
 // src/commands/auth-cmd.ts
-function waitForEnter(prompt2) {
-  return new Promise((resolve9) => {
-    const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, output: process.stdout });
-    rl.question(prompt2, () => {
-      rl.close();
-      resolve9();
-    });
-  });
-}
 async function authCommand(url) {
   console.log();
   showLogo();
@@ -2447,9 +2989,10 @@ async function authCommand(url) {
     console.log(import_chalk3.default.red(`  Not a valid URL: ${url}`));
     return;
   }
-  console.log(import_chalk3.default.white("  A browser will open. Sign in to the site, then come back here."));
+  console.log(import_chalk3.default.white("  A browser will open. Sign in, then leave it on the page demos"));
+  console.log(import_chalk3.default.white("  should start from (usually your dashboard) and come back here."));
   console.log();
-  const browser = await import_playwright2.chromium.launch({ headless: false });
+  const browser = await launchSignInBrowser();
   const context = await browser.newContext();
   const page = await context.newPage();
   try {
@@ -2459,11 +3002,15 @@ async function authCommand(url) {
   await waitForEnter(import_chalk3.default.cyan("  Press Enter when you are signed in... "));
   try {
     const state = await context.storageState();
-    const path = await saveAuthState(url, state);
+    const startUrl = captureStartUrl(context, url);
+    const path = await saveAuthState(url, state, startUrl);
     console.log();
     console.log(import_chalk3.default.green(`  \u2713 Session saved for ${new URL(url).host}`));
     console.log(import_chalk3.default.dim(`  ${formatClickablePath(path)}`));
     console.log(import_chalk3.default.dim("  Crawls and recordings of this site now start signed in."));
+    if (startUrl && startUrl !== url) {
+      console.log(import_chalk3.default.dim("  Demos of the bare URL will start at ") + import_chalk3.default.cyan(startUrl));
+    }
     console.log(import_chalk3.default.dim("  Run ") + import_chalk3.default.cyan(`qp auth clear ${new URL(url).host}`) + import_chalk3.default.dim(" to forget it."));
   } finally {
     await browser.close().catch(() => {
@@ -2505,24 +3052,31 @@ var import_chalk11 = __toESM(require("chalk"));
 init_lib();
 
 // src/ai/client.ts
-var import_node_readline3 = require("readline");
+var import_node_readline2 = require("readline");
 var import_chalk5 = __toESM(require("chalk"));
 init_lib();
 
 // src/utils/browser-auth.ts
-var import_node_http = require("http");
+var import_node_http2 = require("http");
 var import_node_url = require("url");
 var import_chalk4 = __toESM(require("chalk"));
-init_SparkStripe_feature_gating();
-var TIMEOUT_MS = 12e4;
-async function openBrowser(url) {
-  const { exec: exec2 } = await import("child_process");
+
+// src/lib/browser-open.ts
+var import_node_child_process4 = require("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((resolve9) => {
-    exec2(command, () => resolve9());
+    (0, import_node_child_process4.exec)(command, () => resolve9());
   });
 }
+
+// src/utils/browser-auth.ts
+init_SparkStripe_feature_gating();
+var TIMEOUT_MS = 12e4;
 async function browserLogin() {
   return new Promise((resolve9) => {
     let server;
@@ -2532,7 +3086,7 @@ async function browserLogin() {
       server?.close();
       resolve9(email);
     };
-    server = (0, import_node_http.createServer)((req, res) => {
+    server = (0, import_node_http2.createServer)((req, res) => {
       const url = new import_node_url.URL(req.url || "/", `http://localhost`);
       const path = url.pathname;
       if (path === "/callback" || path === "/") {
@@ -2576,7 +3130,7 @@ async function browserLogin() {
       console.log(import_chalk4.default.dim(`  ${url}`));
       console.log();
       console.log(import_chalk4.default.dim("  Waiting for sign-in (press Ctrl+C to cancel)..."));
-      openBrowser(url);
+      void openInBrowser(url);
     });
     timer = setTimeout(() => {
       console.log();
@@ -2586,13 +3140,132 @@ async function browserLogin() {
   });
 }
 
+// src/utils/logging.ts
+var import_promises8 = require("fs/promises");
+var import_node_path9 = require("path");
+var LOG_FILE_NAME = "quickpeek.log";
+var logFileInitialized = false;
+var logFilePath = LOG_FILE_NAME;
+async function writeLogEntry(entry) {
+  try {
+    if (!logFileInitialized) {
+      await (0, import_promises8.writeFile)(logFilePath, entry);
+      logFileInitialized = true;
+    } else {
+      await (0, import_promises8.appendFile)(logFilePath, entry);
+    }
+  } catch {
+  }
+}
+async function setLogFilePath(outputDir) {
+  logFilePath = (0, import_node_path9.join)(outputDir, LOG_FILE_NAME);
+  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
+${"=".repeat(60)}
+
+`;
+  try {
+    await (0, import_promises8.mkdir)((0, import_node_path9.dirname)(logFilePath), { recursive: true });
+    await (0, import_promises8.writeFile)(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
+var import_node_async_hooks = require("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 import_node_async_hooks.AsyncLocalStorage();
+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);
+}
+
 // src/ai/client.ts
 var lastRateLimitInfo = null;
+function wrap(text, width) {
+  const lines = [];
+  for (const paragraph of text.split("\n")) {
+    let current = "";
+    for (const word of paragraph.split(/\s+/).filter(Boolean)) {
+      if (current && current.length + word.length + 1 > width) {
+        lines.push(current);
+        current = word;
+      } else {
+        current = current ? `${current} ${word}` : word;
+      }
+    }
+    lines.push(current);
+  }
+  return lines.filter((l) => l.length > 0);
+}
+function diagnose(status, host) {
+  const where = host ?? "the AI service";
+  if (status === void 0) return `Could not reach ${where}. Check your network, then retry.`;
+  if (status === 401 || status === 403) return `${where} rejected the credentials. Run qp login and retry.`;
+  if (status === 413) return `The prompt was too large for ${where}. Shorten the script or the page.`;
+  if (status === 429) return `${where} is rate limiting. Wait for the quota to reset, then retry.`;
+  if (status === 502 || status === 503 || status === 504) {
+    return `${where} could not reach the AI backend (upstream outage). Retry in a few minutes.`;
+  }
+  if (status >= 500) return `${where} failed internally. Retry in a few minutes; if it persists, report this.`;
+  return `${where} rejected the request. See the body above.`;
+}
 function getLastRateLimitInfo() {
   return lastRateLimitInfo;
 }
 function prompt(question) {
-  const rl = (0, import_node_readline3.createInterface)({ input: process.stdin, output: process.stdout });
+  const rl = (0, import_node_readline2.createInterface)({ input: process.stdin, output: process.stdout });
   return new Promise((resolve9) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -2635,15 +3308,33 @@ 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(
+      import_chalk5.default.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(import_chalk5.default.red("  \u26A0 Rate Limit Reached (after 3 retries)"));
       console.log();
-      console.log(import_chalk5.default.dim("  Spark AI daily limit exceeded. You may have hit your quota."));
+      console.log(import_chalk5.default.dim(`  ${result.error}`));
       console.log(import_chalk5.default.dim("  Options:"));
       if (result.retryAfterSeconds) {
         const minutes = Math.ceil(result.retryAfterSeconds / 60);
@@ -2658,17 +3349,31 @@ async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "
     }
     if (result.isAuthError) {
       console.log();
-      console.log(import_chalk5.default.red("  \u26A0 Authentication Error"));
+      console.log(import_chalk5.default.red(`  \u26A0 Authentication Error${result.status ? ` (HTTP ${result.status})` : ""}`));
       console.log();
-      console.log(import_chalk5.default.dim(`  ${result.error}`));
+      for (const line of wrap(result.error, 76)) {
+        console.log(import_chalk5.default.dim(`  ${line}`));
+      }
+      console.log();
+      console.log(import_chalk5.default.dim(`  ${diagnose(result.status, result.host)}`));
       console.log();
       process.exit(1);
     }
     console.log();
-    console.log(import_chalk5.default.red("  \u26A0 AI Error"));
+    console.log(import_chalk5.default.red(`  \u26A0 AI Error${result.status ? ` (HTTP ${result.status})` : ""}`));
     console.log();
-    const firstLine = result.error.split("\n")[0] ?? result.error;
-    console.log(import_chalk5.default.dim(`  ${firstLine.slice(0, 80)}`));
+    for (const line of wrap(result.error, 76)) {
+      console.log(import_chalk5.default.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(import_chalk5.default.dim(`  ${line}`));
+      }
+    }
+    console.log();
+    console.log(import_chalk5.default.dim(`  ${diagnose(result.status, result.host)}`));
+    console.log(import_chalk5.default.dim(`  Full response body: ${logFilePath}`));
     console.log();
     process.exit(1);
   }
@@ -2676,7 +3381,48 @@ async function callGroq(systemPrompt, userPrompt, logError2, userEmail, tier = "
   return result.content;
 }
 
+// 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/ai/narrate.ts
+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 generateCaptionsForSteps(steps, url, title, lang, logError2, userEmail, pageContext, tier = "free") {
   const langName = getLanguageName(lang);
   const stepList = steps.map((s, i) => {
@@ -2702,33 +3448,34 @@ Steps to caption:
 ${stepList}
 
 Return exactly ${steps.length} captions as a JSON array.`;
-  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier);
-  const arrayMatch = content.match(/\[[\s\S]*\]/);
-  if (!arrayMatch) throw new Error("No JSON array in AI caption response");
-  const captions = JSON.parse(arrayMatch[0]);
+  const content = await callGroq(systemPrompt, userMessage, logError2, userEmail, tier, "narration");
+  const parsed = parseAIJson(content);
+  if (!parsed || !Array.isArray(parsed.value)) throw new Error("No JSON array in AI caption response");
+  const captions = parsed.value;
   return steps.map((s, i) => ({
     ...s,
     id: i + 1,
     caption: toTitleCase(captions[i] ?? `Step ${i + 1}.`)
   }));
 }
-async function generatePlanFromScript(captions, url, title, pageElementsText, lang, logError2, userEmail, tier = "free") {
+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}
@@ -2736,22 +3483,46 @@ 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/browser/events-to-plan.ts
@@ -2858,152 +3629,9 @@ function normalizeUrl2(url) {
 }
 
 // src/capture.ts
-var import_node_child_process4 = require("child_process");
+var import_node_child_process5 = require("child_process");
 var import_node_http3 = require("http");
-var import_node_readline4 = require("readline");
 var import_playwright4 = require("playwright");
-
-// src/browser/wsl.ts
-var import_node_child_process3 = require("child_process");
-var import_node_fs5 = require("fs");
-var import_node_http2 = require("http");
-var import_playwright3 = require("playwright");
-function isWSL() {
-  if (process.platform !== "linux") return false;
-  try {
-    const r = (0, import_node_child_process3.execSync)("uname -r", { encoding: "utf-8" }).toLowerCase();
-    return r.includes("microsoft") || r.includes("wsl");
-  } catch {
-    return false;
-  }
-}
-function tryEnableWSLInterop() {
-  return (0, import_node_fs5.existsSync)("/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 ((0, import_node_fs5.existsSync)(p)) return p;
-  try {
-    const line = (0, import_node_child_process3.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 = (0, import_node_child_process3.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 = (0, import_node_fs5.readFileSync)("/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((resolve9, reject) => {
-    const proc = (0, import_node_child_process3.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);
-        resolve9({ proc, port: +m[1] });
-      }
-    });
-    proc.on("error", (e) => {
-      clearTimeout(timer);
-      reject(e);
-    });
-  });
-}
-function waitForChrome(host, port) {
-  return new Promise((resolve9, 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 = (0, import_node_http2.request)({ host, port, path: "/json/version", method: "GET" }, (res) => {
-        res.resume();
-        resolve9();
-      });
-      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 = (0, import_node_child_process3.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 import_playwright3.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/capture.ts
 var EVENT_TRACKER_SCRIPT = `
 (function () {
   if (window.__qpTracking) return;
@@ -3115,16 +3743,6 @@ var EVENT_TRACKER_SCRIPT = `
   }, { passive: true, capture: true });
 }());
 `;
-function waitForEnter2() {
-  return new Promise((resolve9) => {
-    const rl = (0, import_node_readline4.createInterface)({ input: process.stdin, output: process.stdout });
-    process.stdout.write("  Press Enter when done...\n");
-    rl.once("line", () => {
-      rl.close();
-      resolve9();
-    });
-  });
-}
 async function launchCaptureChrome() {
   const debugPort = 9222;
   const chromePath = findWindowsChrome();
@@ -3150,9 +3768,9 @@ async function launchCaptureChrome() {
     return { browser, relay: probe.proc };
   }
   probe.proc.kill();
-  const winTemp = (0, import_node_child_process4.execSync)("cmd.exe /c echo %TEMP%", { encoding: "utf-8" }).trim().replace(/\r$/, "");
+  const winTemp = (0, import_node_child_process5.execSync)("cmd.exe /c echo %TEMP%", { encoding: "utf-8" }).trim().replace(/\r$/, "");
   const userDataDir = `${winTemp}\\qp-capture`;
-  (0, import_node_child_process4.spawn)(
+  (0, import_node_child_process5.spawn)(
     chromePath,
     [
       `--remote-debugging-port=${debugPort}`,
@@ -3223,7 +3841,7 @@ async function captureUserSession(url, _workDir) {
     return [title, parts.join(" | ")];
   }).catch(() => ["", ""]);
   startTime = Date.now();
-  await waitForEnter2();
+  await waitForEnter();
   const durationMs = Date.now() - startTime;
   if (relay) {
     try {
@@ -3235,86 +3853,28 @@ async function captureUserSession(url, _workDir) {
     await context.close();
     await browser.close();
   }
-  return { events, durationMs, pageTitle, pageContext };
-}
-
-// src/utils/logging.ts
-var import_promises6 = require("fs/promises");
-var import_node_path9 = require("path");
-var LOG_FILE_NAME = "quickpeek.log";
-var logFileInitialized = false;
-var logFilePath = LOG_FILE_NAME;
-async function writeLogEntry(entry) {
-  try {
-    if (!logFileInitialized) {
-      await (0, import_promises6.writeFile)(logFilePath, entry);
-      logFileInitialized = true;
-    } else {
-      await (0, import_promises6.appendFile)(logFilePath, entry);
-    }
-  } catch {
-  }
-}
-async function setLogFilePath(outputDir) {
-  logFilePath = (0, import_node_path9.join)(outputDir, LOG_FILE_NAME);
-  const header2 = `QuickPeek Log - ${(/* @__PURE__ */ new Date()).toISOString()}
-${"=".repeat(60)}
-
-`;
-  try {
-    await (0, import_promises6.writeFile)(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}
-`);
+  return { events, durationMs, pageTitle, pageContext };
 }
 
 // src/commands/phases/video-phase.ts
-var import_node_fs12 = require("fs");
-var import_promises13 = require("fs/promises");
+var import_node_fs13 = require("fs");
+var import_promises14 = require("fs/promises");
 var import_node_path18 = require("path");
 init_lib();
 
 // src/record.ts
-var import_node_fs10 = require("fs");
-var import_promises10 = require("fs/promises");
+var import_node_fs11 = require("fs");
+var import_promises11 = require("fs/promises");
 var import_node_path15 = require("path");
 var import_chalk6 = __toESM(require("chalk"));
 
 // src/browser/actions.ts
-var import_node_fs7 = require("fs");
-var import_promises7 = require("fs/promises");
+var import_node_fs8 = require("fs");
+var import_promises9 = require("fs/promises");
 var import_node_path11 = require("path");
 
 // src/browser/effects.ts
-var import_node_fs6 = require("fs");
+var import_node_fs7 = require("fs");
 var import_node_path10 = require("path");
 init_lib();
 function loadHighlightCSS() {
@@ -3325,7 +3885,7 @@ function loadHighlightCSS() {
     // src/browser/ → src/
   ];
   for (const p of candidates) {
-    if ((0, import_node_fs6.existsSync)(p)) return (0, import_node_fs6.readFileSync)(p, "utf-8");
+    if ((0, import_node_fs7.existsSync)(p)) return (0, import_node_fs7.readFileSync)(p, "utf-8");
   }
   return "";
 }
@@ -3525,6 +4085,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;
@@ -3649,7 +4213,14 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
         }
       } else {
         const amount = direction === "up" ? -PAGE_SCROLL_PX : PAGE_SCROLL_PX;
-        await page.evaluate((y) => window.scrollBy(0, y), amount);
+        const moved = await page.evaluate((y) => {
+          const before = window.scrollY;
+          window.scrollBy(0, y);
+          return window.scrollY - before;
+        }, amount);
+        if (moved === 0) {
+          throw new Error("scroll moved nothing: the page has no scroll headroom at this viewport");
+        }
       }
       break;
     }
@@ -3667,7 +4238,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
           if (!isPlaceholder) {
             const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
             const filePath = (0, import_node_path11.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path11.resolve)(baseDir, normalizedPath);
-            if ((0, import_node_fs7.existsSync)(filePath)) {
+            if ((0, import_node_fs8.existsSync)(filePath)) {
               await fileInput.setInputFiles(filePath);
               await page.waitForTimeout(2e3);
               break;
@@ -3784,7 +4355,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
       break;
     case "image": {
       const imagePath = step.value ? (0, import_node_path11.isAbsolute)(step.value) ? step.value : (0, import_node_path11.resolve)(baseDir, step.value) : null;
-      if (imagePath && (0, import_node_fs7.existsSync)(imagePath)) {
+      if (imagePath && (0, import_node_fs8.existsSync)(imagePath)) {
         const imgStyle = step.target === "stretch" ? `width: ${config.video.width}px; height: ${config.video.height}px; object-fit: cover;` : "max-width: 90%; max-height: 90%;";
         if (await showImagePage(page, imagePath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -3814,7 +4385,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
         await pendingDownload;
         pendingDownload = null;
       }
-      if (lastDownloadPath && (0, import_node_fs7.existsSync)(lastDownloadPath)) {
+      if (lastDownloadPath && (0, import_node_fs8.existsSync)(lastDownloadPath)) {
         const imgStyle = step.target === "stretch" ? "width: 100%; height: 100%; object-fit: contain;" : "max-width: 90%; max-height: 90%; object-fit: contain;";
         if (await showImagePage(page, lastDownloadPath, imgStyle, config, cursorInjected)) injected = true;
       }
@@ -3825,7 +4396,7 @@ async function executeStep(page, step, plan, config, cursorInjected, baseDir) {
 async function showImagePage(page, filePath, imgStyle, config, cursorInjected) {
   const { width, height } = config.video;
   const ext = filePath.split(".").pop()?.toLowerCase() || "";
-  const fileBuffer = await (0, import_promises7.readFile)(filePath);
+  const fileBuffer = await (0, import_promises9.readFile)(filePath);
   const base64 = fileBuffer.toString("base64");
   const mimeTypes = {
     png: "image/png",
@@ -3854,64 +4425,6 @@ async function showImagePage(page, filePath, imgStyle, config, cursorInjected) {
   return false;
 }
 
-// src/browser/launch.ts
-var import_promises8 = require("fs/promises");
-var import_playwright5 = require("playwright");
-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 (0, import_promises8.mkdir)(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 import_playwright5.chromium.launchPersistentContext(userDataDir, {
-          headless: false,
-          args: persistentArgs,
-          viewport,
-          ...videoOpts,
-          acceptDownloads: true
-        });
-      }
-    } else {
-      context = await import_playwright5.chromium.launchPersistentContext(userDataDir, {
-        headless: false,
-        args: persistentArgs,
-        viewport,
-        ...videoOpts,
-        acceptDownloads: true
-      });
-    }
-  } else {
-    browser = await import_playwright5.chromium.launch({ headless: true });
-    context = await browser.newContext({ viewport, ...videoOpts, ...authOpts, acceptDownloads: true });
-  }
-  return { context, browser, chromeSession };
-}
-async function cleanupBrowserSession(session) {
-  if (session.chromeSession) {
-    await session.chromeSession.cleanup();
-  } else {
-    await session.context.close();
-    if (session.browser) await session.browser.close();
-  }
-}
-
 // src/record.ts
 init_lib();
 
@@ -3920,16 +4433,16 @@ var import_node_path13 = require("path");
 init_utils();
 
 // src/browser/step-validator.ts
-var import_node_fs8 = require("fs");
+var import_node_fs9 = require("fs");
 var import_node_path12 = require("path");
 init_utils();
 function findMediaFile(filename, baseDir) {
   const name = (0, import_node_path12.basename)(filename);
   const searchDirs = [baseDir, (0, import_node_path12.join)(baseDir, "res"), (0, import_node_path12.join)(baseDir, "assets"), (0, import_node_path12.join)(baseDir, "media")];
   for (const dir of searchDirs) {
-    if (!(0, import_node_fs8.existsSync)(dir)) continue;
+    if (!(0, import_node_fs9.existsSync)(dir)) continue;
     try {
-      const files = (0, import_node_fs8.readdirSync)(dir);
+      const files = (0, import_node_fs9.readdirSync)(dir);
       if (files.includes(name)) return (0, import_node_path12.join)(dir, name);
       const match = files.find((f) => f.toLowerCase() === name.toLowerCase());
       if (match) return (0, import_node_path12.join)(dir, match);
@@ -4005,7 +4518,7 @@ function resolveMediaStep(step, baseDir, label, startTime) {
     return { success: false, error: `Missing ${label} path`, executionTimeMs: Date.now() - startTime };
   }
   const specifiedPath = (0, import_node_path12.isAbsolute)(step.value) ? step.value : (0, import_node_path12.resolve)(baseDir, step.value);
-  if ((0, import_node_fs8.existsSync)(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
+  if ((0, import_node_fs9.existsSync)(specifiedPath)) return { success: true, executionTimeMs: Date.now() - startTime };
   const foundPath = findMediaFile(step.value, baseDir);
   if (foundPath) {
     step.value = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -4127,7 +4640,7 @@ async function validateAndExecuteStep(page, step, plan, baseDir) {
         if (!isPlaceholder) {
           const normalizedPath = rawPath.startsWith("mnt/") ? `/${rawPath}` : rawPath;
           let filePath = (0, import_node_path12.isAbsolute)(normalizedPath) ? normalizedPath : (0, import_node_path12.resolve)(baseDir, normalizedPath);
-          if (!(0, import_node_fs8.existsSync)(filePath)) {
+          if (!(0, import_node_fs9.existsSync)(filePath)) {
             const foundPath = findMediaFile(rawPath, baseDir);
             if (foundPath) {
               const relativePath = `./${foundPath.replace(`${baseDir}/`, "").replace(`${baseDir}\\`, "")}`;
@@ -4291,8 +4804,8 @@ async function validateStepsOnPage(plan, config, logError2, baseDir, onStepStart
 }
 
 // src/browser/meta.ts
-var import_node_fs9 = require("fs");
-var import_promises9 = require("fs/promises");
+var import_node_fs10 = require("fs");
+var import_promises10 = require("fs/promises");
 var import_node_path14 = require("path");
 var RECORDING_FILE = "recording.mp4";
 var RECORDING_META_FILE = "recording.meta.json";
@@ -4301,9 +4814,9 @@ function getRecordingPath(outputDir) {
 }
 async function loadRecordingMeta(outputDir) {
   const metaPath = (0, import_node_path14.join)(outputDir, RECORDING_META_FILE);
-  if (!(0, import_node_fs9.existsSync)(metaPath)) return null;
+  if (!(0, import_node_fs10.existsSync)(metaPath)) return null;
   try {
-    const content = await (0, import_promises9.readFile)(metaPath, "utf-8");
+    const content = await (0, import_promises10.readFile)(metaPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -4311,7 +4824,7 @@ async function loadRecordingMeta(outputDir) {
 }
 async function saveRecordingMeta(outputDir, meta) {
   const metaPath = (0, import_node_path14.join)(outputDir, RECORDING_META_FILE);
-  await (0, import_promises9.writeFile)(metaPath, JSON.stringify(meta, null, 2));
+  await (0, import_promises10.writeFile)(metaPath, JSON.stringify(meta, null, 2));
 }
 function canReuseRecording(plan, config, stepDurations, existingMeta) {
   if (!existingMeta) {
@@ -4381,14 +4894,14 @@ function formatStepLabel(step) {
 }
 async function recordSession(plan, config, stepDurations, workDir, baseDir, task2, logError2) {
   const videoDir = (0, import_node_path15.join)(workDir, "video");
-  await (0, import_promises10.mkdir)(videoDir, { recursive: true });
+  await (0, import_promises11.mkdir)(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 = (0, import_node_path15.join)(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();
@@ -4409,6 +4922,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;
@@ -4435,6 +4949,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;
@@ -4471,11 +4991,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(import_chalk6.default.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;
@@ -4493,13 +5021,14 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
       console.log(import_chalk6.default.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 || !(0, import_node_fs10.existsSync)(videoPath)) {
+  if (!videoPath || !(0, import_node_fs11.existsSync)(videoPath)) {
     throw new Error("Video file was not created");
   }
   saveTask.succeed("Video saved");
@@ -4508,8 +5037,8 @@ async function recordSession(plan, config, stepDurations, workDir, baseDir, task
 
 // src/utils/video-pipeline.ts
 var import_video_kit6 = require("@spark-apps/video-kit");
-var import_node_fs11 = require("fs");
-var import_promises11 = require("fs/promises");
+var import_node_fs12 = require("fs");
+var import_promises12 = require("fs/promises");
 var import_node_path16 = require("path");
 var import_chalk7 = __toESM(require("chalk"));
 init_lib();
@@ -4560,7 +5089,7 @@ async function generateASS(plan, stepAudio, workDir, config, captions) {
     currentTime += audio.duration;
   }
   const assPath = (0, import_node_path16.join)(workDir, "subtitles.ass");
-  await (0, import_promises11.writeFile)(assPath, ass);
+  await (0, import_promises12.writeFile)(assPath, ass);
   return assPath;
 }
 function buildVideoOverlays(steps, stepDurations, baseDir) {
@@ -4574,7 +5103,7 @@ function buildVideoOverlays(steps, stepDurations, baseDir) {
       const ext = step.value.split(".").pop()?.toLowerCase() || "";
       if (["mp4", "webm", "mov"].includes(ext)) {
         const mediaPath = (0, import_node_path16.isAbsolute)(step.value) ? step.value : (0, import_node_path16.resolve)(baseDir, step.value);
-        if ((0, import_node_fs11.existsSync)(mediaPath)) {
+        if ((0, import_node_fs12.existsSync)(mediaPath)) {
           const partial = parsePartial(step.partial);
           overlays.push({
             path: mediaPath,
@@ -4603,13 +5132,13 @@ async function composeAndFinish(videoPath, audioPath, assPath, config, userTier
     process.exit(0);
   }
   const composeTask = task("Building final video");
-  await (0, import_promises11.mkdir)(config.output.dir, { recursive: true });
+  await (0, import_promises12.mkdir)(config.output.dir, { recursive: true });
   const suffix = config.lang ? `-${config.lang}` : "";
   const finalPath = (0, import_node_path16.join)(config.output.dir, `demo${suffix}.${config.video.format}`);
   const videoDuration = await getMediaDuration(videoPath) / 1e3;
-  const hasVoiceover = audioPath && (0, import_node_fs11.existsSync)(audioPath);
+  const hasVoiceover = audioPath && (0, import_node_fs12.existsSync)(audioPath);
   const musicPath = config.music?.path ? (0, import_node_path16.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path16.resolve)(config.output.dir, config.music.path) : "";
-  const hasMusic = musicPath && (0, import_node_fs11.existsSync)(musicPath);
+  const hasMusic = musicPath && (0, import_node_fs12.existsSync)(musicPath);
   try {
     await composeVideo({
       videoPath,
@@ -4674,19 +5203,20 @@ var import_chalk9 = __toESM(require("chalk"));
 init_lib();
 
 // src/plan.ts
-var import_promises12 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 var import_node_path17 = require("path");
 var import_chalk8 = __toESM(require("chalk"));
-var import_playwright6 = require("playwright");
+var import_playwright5 = require("playwright");
 init_lib();
+init_json_repair();
 async function crawlExtension(url, extensionPath, workDir, task2) {
   const browserTask = task2("Launching browser with extension");
   const userDataDir = (0, import_node_path17.join)(workDir, ".browser-data");
-  await (0, import_promises12.mkdir)(userDataDir, { recursive: true });
+  await (0, import_promises13.mkdir)(userDataDir, { recursive: true });
   let context;
   let chromeSession = null;
   const useWindowsChrome = isWSL() && tryEnableWSLInterop();
-  const launchPersistent = () => import_playwright6.chromium.launchPersistentContext(userDataDir, {
+  const launchPersistent = () => import_playwright5.chromium.launchPersistentContext(userDataDir, {
     headless: false,
     args: [
       `--disable-extensions-except=${extensionPath}`,
@@ -4767,7 +5297,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,
@@ -4779,43 +5309,19 @@ async function crawlExtension(url, extensionPath, workDir, task2) {
   crawlTask.succeed(`Found ${elements.length} interactive elements`);
   return { title, elements };
 }
-var JSON_FIX_SYSTEM_PROMPT = "You fix malformed JSON. Return ONLY valid JSON, no explanation.";
-var jsonFixUserPrompt = (content) => `Fix this malformed JSON plan. Return ONLY valid JSON, no explanation.
-The JSON should have: url, title, description, steps array.
-Each step has: id (number), action, caption, and optionally target, value.
-
-Malformed content:
-${content}`;
 async function parsePlanJson(content, task2, logError2, userEmail, tier = "free") {
-  try {
-    return JSON.parse(content);
-  } catch {
-    const fixTask = task2("Fixing malformed JSON");
-    try {
-      const fixed = await callGroq(JSON_FIX_SYSTEM_PROMPT, jsonFixUserPrompt(content), logError2, userEmail, tier);
-      const jsonMatch = fixed.match(/\{[\s\S]*\}/);
-      if (!jsonMatch) throw new Error("No JSON in fix");
-      const plan = JSON.parse(jsonMatch[0]);
-      fixTask.succeed("JSON fixed by AI");
-      return plan;
-    } catch (err) {
-      await logError2("JSON Fix", err);
-      fixTask.fail("Could not fix JSON");
-      throw new Error(`Malformed JSON: ${getErrorMessage(err)}`);
-    }
-  }
+  return parseAIJsonWithRepair(content, { logError: logError2, task: task2, userEmail, tier });
 }
-async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError2, userEmail, extensionPath, workDir, tier = "free") {
-  const { title, elements } = extensionPath && workDir ? await crawlExtension(url, extensionPath, workDir, task2) : await crawlPage(url, task2, findAuthState(url));
+async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError2, userEmail, extensionPath, workDir, tier = "free", viewport) {
+  const { title, elements, scrollable } = extensionPath && workDir ? { ...await crawlExtension(url, extensionPath, workDir, task2), scrollable: void 0 } : await crawlPage(url, task2, findAuthState(url), viewport);
   const aiTask = task2("Generating plan with AI");
   const langName = getLanguageName(lang);
   const systemPrompt = buildSystemPrompt(maxSteps);
-  const userPrompt = buildUserPrompt(url, title, elements, langName, description, maxSteps);
+  const userPrompt = buildUserPrompt(url, title, elements, langName, description, maxSteps, scrollable);
   try {
-    const content = await callGroq(systemPrompt, userPrompt, logError2, userEmail, tier);
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) throw new Error("No JSON found in response");
-    const plan = await parsePlanJson(jsonMatch[0], task2, logError2, userEmail, tier);
+    const content = await callGroq(systemPrompt, userPrompt, logError2, userEmail, tier, "plan");
+    const plan = await parsePlanJson(content, task2, logError2, userEmail, tier);
+    if (!Array.isArray(plan.steps)) throw new Error("AI response has no steps array");
     if (lang !== void 0) plan.lang = lang;
     plan.steps = plan.steps.map(({ duration, ...s }, i) => ({
       ...s,
@@ -4832,14 +5338,14 @@ async function crawlAndAnalyze(url, lang, description, maxSteps, task2, logError
   }
 }
 async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier = "free") {
-  const content = await (0, import_promises12.readFile)(planPath, "utf-8");
+  const content = await (0, import_promises13.readFile)(planPath, "utf-8");
   const plan = await parsePlanJson(content, task2, logError2, userEmail, tier);
   if (!plan.url || !plan.steps || !Array.isArray(plan.steps)) {
     throw new Error("Invalid plan: missing url or steps");
   }
   const renumberTask = task2("Validating plan structure");
   const originalCount = plan.steps.length;
-  const INVALID_TARGETS = [/\.png$/i, /\.jpg$/i, /\.gif$/i, /\.webp$/i, /\.svg$/i, /sprite_sheet/i, /downloaded/i];
+  const INVALID_TARGETS2 = [/\.png$/i, /\.jpg$/i, /\.gif$/i, /\.webp$/i, /\.svg$/i, /sprite_sheet/i, /downloaded/i];
   const isValidStep = (s) => {
     if (!s?.action) return false;
     if (s.action === "navigate") {
@@ -4848,7 +5354,7 @@ async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier =
     }
     if (["click", "type", "select", "check", "upload", "drag"].includes(s.action)) {
       if (!s.target) return false;
-      if (INVALID_TARGETS.some((pattern) => pattern.test(s.target))) return false;
+      if (INVALID_TARGETS2.some((pattern) => pattern.test(s.target))) return false;
     }
     if (s.action === "upload") {
       if (!s.target?.includes("file") && !s.target?.includes("input")) return false;
@@ -4865,7 +5371,7 @@ async function validateAndFixPlan(planPath, task2, logError2, userEmail, tier =
     renumberTask.fail("No valid steps");
     throw new Error("Plan has no valid steps");
   }
-  await (0, import_promises12.writeFile)(planPath, JSON.stringify(plan, null, 2));
+  await (0, import_promises13.writeFile)(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`
@@ -4980,6 +5486,21 @@ function getOutputDirFromUrl(url) {
 
 // src/commands/phases/video-phase.ts
 var INDENT4 = "   ";
+function resolveOutro(config, userTier) {
+  if (userTier !== "free") {
+    const custom = config.video.outro?.trim();
+    if (!custom) return void 0;
+    const path = (0, import_node_path18.resolve)(custom);
+    if ((0, import_node_fs13.existsSync)(path)) return path;
+    info(`${INDENT4}\u26A0 outro not found: ${path}`);
+    return void 0;
+  }
+  const scriptDir = getScriptDir();
+  const bundled = (0, import_node_path18.join)(scriptDir, "assets", "qp.wm");
+  if ((0, import_node_fs13.existsSync)(bundled)) return bundled;
+  const fallback = (0, import_node_path18.join)(scriptDir, "..", "dist", "assets", "qp.wm");
+  return (0, import_node_fs13.existsSync)(fallback) ? fallback : void 0;
+}
 async function runVideoPhase(params) {
   let { stepAudio } = params;
   const { plan, config, voiceoverPath, workDir, captions, userTier } = params;
@@ -4998,7 +5519,7 @@ async function runVideoPhase(params) {
               mediaDuration = (trimEnd - trimStart2) * 1e3;
             } else {
               const mediaPath = (0, import_node_path18.resolve)(s.value);
-              if ((0, import_node_fs12.existsSync)(mediaPath)) {
+              if ((0, import_node_fs13.existsSync)(mediaPath)) {
                 try {
                   const fullDuration = await getMediaDuration(mediaPath);
                   const start = (trimStart2 ?? 0) * 1e3;
@@ -5010,7 +5531,7 @@ async function runVideoPhase(params) {
             }
           } else {
             const mediaPath = (0, import_node_path18.resolve)(s.value);
-            if ((0, import_node_fs12.existsSync)(mediaPath)) {
+            if ((0, import_node_fs13.existsSync)(mediaPath)) {
               try {
                 mediaDuration = await getMediaDuration(mediaPath);
               } catch {
@@ -5023,7 +5544,7 @@ async function runVideoPhase(params) {
     })
   );
   const recordingPath = getRecordingPath(config.output.dir);
-  const hasExistingRecording = existingRecordingMeta && (0, import_node_fs12.existsSync)(recordingPath);
+  const hasExistingRecording = existingRecordingMeta && (0, import_node_fs13.existsSync)(recordingPath);
   let videoPath = recordingPath;
   const firstStep = plan.steps[0];
   const firstStepIsVideo = firstStep && (firstStep.action === "video" || firstStep.action === "media");
@@ -5032,7 +5553,7 @@ async function runVideoPhase(params) {
     header("Record");
     const result = await recordSession(plan, config, stepDurations, workDir, config.output.dir, task, logError);
     stepAudio = await alignVoiceoverToRecording(stepAudio, result.actualStepDurations, workDir, config.output.dir);
-    await (0, import_promises13.copyFile)(result.videoPath, recordingPath);
+    await (0, import_promises14.copyFile)(result.videoPath, recordingPath);
     const meta = buildRecordingMeta(plan, config, result.actualStepDurations);
     meta.pageLoadTime = result.pageLoadTime;
     await saveRecordingMeta(config.output.dir, meta);
@@ -5084,7 +5605,7 @@ async function runVideoPhase(params) {
     const transitionTask = task("Applying transitions");
     try {
       const transitionedPath = (0, import_node_path18.join)(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,
@@ -5102,30 +5623,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 = (0, import_node_path18.join)(scriptDir, "assets", "qp.wm");
-    if (!(0, import_node_fs12.existsSync)(outroPath)) {
-      outroPath = (0, import_node_path18.join)(scriptDir, "..", "dist", "assets", "qp.wm");
-    }
-    if ((0, import_node_fs12.existsSync)(outroPath)) {
-      try {
-        const mainDuration = await getMediaDuration(videoPath);
-        mainContentDuration = mainDuration / 1e3 - trimStart;
-        const combinedPath = (0, import_node_path18.join)(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 = (0, import_node_path18.join)(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(
@@ -5159,7 +5674,7 @@ async function runVideoPhase(params) {
 }
 
 // src/commands/phases/voiceover-phase.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_path19 = require("path");
 var import_chalk10 = __toESM(require("chalk"));
 init_lib();
@@ -5169,9 +5684,9 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
     const filesToDelete = ["voiceover.json", "voiceover.wav", "recording.meta.json"];
     for (const file of filesToDelete) {
       const filePath = (0, import_node_path19.join)(config.output.dir, file);
-      if ((0, import_node_fs13.existsSync)(filePath)) {
-        const { unlink: unlink3 } = await import("fs/promises");
-        await unlink3(filePath).catch(() => {
+      if ((0, import_node_fs14.existsSync)(filePath)) {
+        const { unlink: unlink4 } = await import("fs/promises");
+        await unlink4(filePath).catch(() => {
         });
       }
     }
@@ -5180,7 +5695,12 @@ async function runVoiceoverPhase(plan, config, workDir, skipVoice, fresh) {
   const voice = resolveVoice(config);
   const existingMeta = await loadVoiceoverMeta(config.output.dir);
   const voiceoverFile = (0, import_node_path19.join)(config.output.dir, "voiceover.wav");
-  const hasExistingVoiceover = existingMeta && (0, import_node_fs13.existsSync)(voiceoverFile);
+  const voiceoverOnDisk = existingMeta && (0, import_node_fs14.existsSync)(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;
@@ -5270,7 +5790,8 @@ async function captureCommand(url, lang) {
       lang,
       logError,
       userData.email,
-      captureResult.pageContext
+      captureResult.pageContext,
+      userData.tier ?? "free"
     );
     narrateTask.succeed(`${steps.length} captions generated`);
   } catch (err) {
@@ -5314,16 +5835,172 @@ async function captureCommand(url, lang) {
   console.log(import_chalk11.default.cyan(`  ${finalPath}`));
 }
 
-// src/commands/init-cmd.ts
-var import_node_fs14 = require("fs");
-var import_promises14 = require("fs/promises");
+// src/commands/edit-cmd.ts
+var import_node_fs15 = require("fs");
 var import_node_path21 = require("path");
 var import_chalk12 = __toESM(require("chalk"));
+
+// src/lib/plan-validation.ts
+var INVALID_TARGETS = [
+  /\.png$/i,
+  /\.jpg$/i,
+  /\.gif$/i,
+  /\.webp$/i,
+  /\.svg$/i,
+  /sprite_sheet/i,
+  /downloaded/i
+];
+var ACTIONS_REQUIRING_TARGET = ["click", "type", "select", "check", "drag"];
+function isFilePath(value) {
+  if (!value) return false;
+  return /\.\w{2,5}$/.test(value) && (/[/\\]/.test(value) || /^[a-zA-Z]:/.test(value));
+}
+function isInvalidTarget(target) {
+  return INVALID_TARGETS.some((pattern) => pattern.test(target));
+}
+function validateStep(step) {
+  if (!step?.action) {
+    return "Missing action";
+  }
+  if (step.action === "navigate") {
+    if (!step.target) return "Navigate requires a URL target";
+    if (!step.target.startsWith("http://") && !step.target.startsWith("https://")) {
+      return "Navigate target must be a valid URL";
+    }
+  }
+  if (step.action === "media") {
+    if (!step.mediaFile && !isFilePath(step.value)) {
+      return "Media step requires a file (image or video)";
+    }
+  }
+  if (step.action === "upload") {
+    if (!step.mediaFile && !isFilePath(step.value)) {
+      return "Upload step requires a file";
+    }
+  }
+  if (ACTIONS_REQUIRING_TARGET.includes(step.action)) {
+    if (!step.target) return `${step.action} requires a target`;
+    if (isInvalidTarget(step.target)) return `Invalid target pattern: ${step.target}`;
+  }
+  return null;
+}
+
+// src/lib/plan-file.ts
+var MAX_HANDOFF_URL_CHARS = 32e3;
+function serializePlan(plan) {
+  return `${JSON.stringify(plan, null, 2)}
+`;
+}
+function parsePlanText(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (e) {
+    return { ok: false, error: `Not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { ok: false, error: "A plan must be a JSON object." };
+  }
+  const candidate = raw;
+  if (typeof candidate.url !== "string" || !candidate.url.trim()) {
+    return { ok: false, error: "A plan needs a `url` to record." };
+  }
+  if (!Array.isArray(candidate.steps) || candidate.steps.length === 0) {
+    return { ok: false, error: "A plan needs at least one step." };
+  }
+  const steps = [];
+  for (const [index, step] of candidate.steps.entries()) {
+    if (!step || typeof step !== "object" || Array.isArray(step)) {
+      return { ok: false, error: `Step ${index + 1} is not an object.` };
+    }
+    const typed = step;
+    if (typeof typed.action !== "string" || !typed.action.trim()) {
+      return { ok: false, error: `Step ${index + 1} has no action.` };
+    }
+    const failure = validateStep(typed);
+    if (failure) return { ok: false, error: `Step ${index + 1}: ${failure}` };
+    steps.push({ ...typed, id: typed.id ?? index + 1 });
+  }
+  return {
+    ok: true,
+    plan: {
+      url: candidate.url,
+      title: candidate.title ?? "",
+      description: candidate.description ?? "",
+      ...candidate.lang ? { lang: candidate.lang } : {},
+      steps
+    }
+  };
+}
+function toBase64Url(text) {
+  const bytes = new TextEncoder().encode(text);
+  const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+  const base64 = typeof btoa === "function" ? btoa(binary) : Buffer.from(text, "utf8").toString("base64");
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function encodePlan(plan) {
+  return toBase64Url(serializePlan(plan));
+}
+function planEditorUrl(baseUrl, plan) {
+  const url = `${baseUrl.replace(/\/$/, "")}/edit#plan=${encodePlan(plan)}`;
+  return url.length <= MAX_HANDOFF_URL_CHARS ? url : null;
+}
+
+// src/commands/edit-cmd.ts
+var PLAN_FILE = /^plan-([a-z]{2}(?:-[A-Z]{2})?)\.json$/;
+function findPlanFile(dir, lang) {
+  if (lang) {
+    const exact = (0, import_node_path21.join)(dir, `plan-${lang}.json`);
+    return (0, import_node_fs15.existsSync)(exact) ? exact : null;
+  }
+  if (!(0, import_node_fs15.existsSync)(dir)) return null;
+  const plans = (0, import_node_fs15.readdirSync)(dir).filter((f) => PLAN_FILE.test(f));
+  const preferred = plans.find((f) => f === "plan-en.json") ?? plans[0];
+  return preferred ? (0, import_node_path21.join)(dir, preferred) : null;
+}
+async function editCommand(url, lang) {
+  console.log();
+  showLogo();
+  const dir = getOutputDirFromUrl(url);
+  const planPath = findPlanFile(dir, lang);
+  if (!planPath) {
+    console.log(import_chalk12.default.red(`  No plan found in ${dir}`));
+    console.log(import_chalk12.default.dim(`  Record the demo first: `) + import_chalk12.default.cyan(`qp ${url}`));
+    console.log();
+    return;
+  }
+  const parsed = parsePlanText((0, import_node_fs15.readFileSync)(planPath, "utf8"));
+  if (!parsed.ok) {
+    console.log(import_chalk12.default.red(`  ${planPath} cannot be opened: ${parsed.error}`));
+    console.log();
+    return;
+  }
+  const base = editorBaseUrl();
+  const editorUrl = planEditorUrl(base, parsed.plan);
+  if (!editorUrl) {
+    console.log(import_chalk12.default.yellow("  This plan is too long to carry in a link."));
+    console.log(import_chalk12.default.dim(`  Open ${base}/edit and load `) + import_chalk12.default.cyan(formatClickablePath(planPath)));
+    console.log();
+    await openInBrowser(`${base}/edit`);
+    return;
+  }
+  await openInBrowser(editorUrl);
+  console.log(import_chalk12.default.green(`  \u2713 Opened ${parsed.plan.steps.length} steps in the editor`));
+  console.log(import_chalk12.default.dim(`  ${formatClickablePath(planPath)}`));
+  console.log(import_chalk12.default.dim("  Save from the editor over this file, then record again."));
+  console.log();
+}
+
+// src/commands/init-cmd.ts
+var import_node_fs16 = require("fs");
+var import_promises15 = require("fs/promises");
+var import_node_path22 = require("path");
+var import_chalk13 = __toESM(require("chalk"));
 init_lib();
 async function initCommand() {
-  const configPath = (0, import_node_path21.join)(process.cwd(), CONFIG_FILE);
-  if ((0, import_node_fs14.existsSync)(configPath)) {
-    console.log(import_chalk12.default.yellow(`  \u26A0 ${CONFIG_FILE} already exists`));
+  const configPath = (0, import_node_path22.join)(process.cwd(), CONFIG_FILE);
+  if ((0, import_node_fs16.existsSync)(configPath)) {
+    console.log(import_chalk13.default.yellow(`  \u26A0 ${CONFIG_FILE} already exists`));
     return;
   }
   const defaultConfig = {
@@ -5346,32 +6023,32 @@ async function initCommand() {
       volume: 0.3
     }
   };
-  await (0, import_promises14.writeFile)(configPath, `${JSON.stringify(defaultConfig, null, 2)}
+  await (0, import_promises15.writeFile)(configPath, `${JSON.stringify(defaultConfig, null, 2)}
 `);
-  console.log(import_chalk12.default.green(`  \u2714 Created ${CONFIG_FILE}`));
-  console.log(import_chalk12.default.dim(`  Edit it or use: qp config <key> <value>`));
+  console.log(import_chalk13.default.green(`  \u2714 Created ${CONFIG_FILE}`));
+  console.log(import_chalk13.default.dim(`  Edit it or use: qp config <key> <value>`));
 }
 async function configCommand(key, value) {
-  const configPath = (0, import_node_path21.join)(process.cwd(), CONFIG_FILE);
+  const configPath = (0, import_node_path22.join)(process.cwd(), CONFIG_FILE);
   if (!key) {
-    if (!(0, import_node_fs14.existsSync)(configPath)) {
-      console.log(import_chalk12.default.yellow(`  No ${CONFIG_FILE} found. Run: qp init`));
+    if (!(0, import_node_fs16.existsSync)(configPath)) {
+      console.log(import_chalk13.default.yellow(`  No ${CONFIG_FILE} found. Run: qp init`));
       return;
     }
-    const content = await (0, import_promises14.readFile)(configPath, "utf-8");
-    console.log(import_chalk12.default.cyan(`  ${CONFIG_FILE}:`));
+    const content = await (0, import_promises15.readFile)(configPath, "utf-8");
+    console.log(import_chalk13.default.cyan(`  ${CONFIG_FILE}:`));
     console.log(content);
     return;
   }
   if (!value) {
-    console.log(import_chalk12.default.red(`  Missing value for ${key}`));
-    console.log(import_chalk12.default.dim(`  Usage: qp config ${key} <value>`));
+    console.log(import_chalk13.default.red(`  Missing value for ${key}`));
+    console.log(import_chalk13.default.dim(`  Usage: qp config ${key} <value>`));
     return;
   }
   let config = {};
-  if ((0, import_node_fs14.existsSync)(configPath)) {
+  if ((0, import_node_fs16.existsSync)(configPath)) {
     try {
-      config = JSON.parse(await (0, import_promises14.readFile)(configPath, "utf-8"));
+      config = JSON.parse(await (0, import_promises15.readFile)(configPath, "utf-8"));
     } catch {
     }
   }
@@ -5393,42 +6070,42 @@ async function configCommand(key, value) {
     }
     obj[keys[keys.length - 1]] = parsedValue;
   }
-  await (0, import_promises14.writeFile)(configPath, `${JSON.stringify(config, null, 2)}
+  await (0, import_promises15.writeFile)(configPath, `${JSON.stringify(config, null, 2)}
 `);
-  console.log(import_chalk12.default.green(`  \u2714 Set ${key} = ${value}`));
+  console.log(import_chalk13.default.green(`  \u2714 Set ${key} = ${value}`));
 }
 
 // src/commands/login-cmd.ts
-var import_chalk13 = __toESM(require("chalk"));
+var import_chalk14 = __toESM(require("chalk"));
 init_lib();
 async function loginCommand() {
   console.log();
   showLogo();
   const existing = await loadUserData();
   if (existing.email && existing.verified) {
-    console.log(import_chalk13.default.dim(`  Already signed in as ${existing.email}`));
-    console.log(import_chalk13.default.dim("  Run ") + import_chalk13.default.cyan("qp logout") + import_chalk13.default.dim(" first to switch accounts."));
+    console.log(import_chalk14.default.dim(`  Already signed in as ${existing.email}`));
+    console.log(import_chalk14.default.dim("  Run ") + import_chalk14.default.cyan("qp logout") + import_chalk14.default.dim(" first to switch accounts."));
     console.log();
     try {
       const status = await getStatusCached(existing.email);
       const tier2 = await getTierByEmail(existing.email);
-      const tierLabel2 = tier2 === "pro" ? import_chalk13.default.green("Pro") : "Free";
+      const tierLabel2 = tier2 === "pro" ? import_chalk14.default.green("Pro") : "Free";
       console.log(`  ${tierLabel2} plan`);
       for (const line of formatUsageLines(status, tier2)) {
-        console.log(import_chalk13.default.dim(`  ${line}`));
+        console.log(import_chalk14.default.dim(`  ${line}`));
       }
     } catch {
     }
     console.log();
     return;
   }
-  console.log(import_chalk13.default.white("  Sign in with your Google account to track usage"));
-  console.log(import_chalk13.default.white("  and unlock Pro features."));
+  console.log(import_chalk14.default.white("  Sign in with your Google account to track usage"));
+  console.log(import_chalk14.default.white("  and unlock Pro features."));
   const email = await browserLogin();
   if (!email) {
     console.log();
-    console.log(import_chalk13.default.yellow("  Sign-in cancelled or timed out."));
-    console.log(import_chalk13.default.dim("  Run ") + import_chalk13.default.cyan("qp login") + import_chalk13.default.dim(" to try again."));
+    console.log(import_chalk14.default.yellow("  Sign-in cancelled or timed out."));
+    console.log(import_chalk14.default.dim("  Run ") + import_chalk14.default.cyan("qp login") + import_chalk14.default.dim(" to try again."));
     console.log();
     return;
   }
@@ -5439,8 +6116,8 @@ async function loginCommand() {
   }
   await saveUserData({ email, verified: true, tier });
   console.log();
-  const tierLabel = tier === "pro" ? import_chalk13.default.green("Pro") : "Free";
-  console.log(import_chalk13.default.green(`  \u2713 Signed in as ${email}`));
+  const tierLabel = tier === "pro" ? import_chalk14.default.green("Pro") : "Free";
+  console.log(import_chalk14.default.green(`  \u2713 Signed in as ${email}`));
   console.log(`  ${tierLabel} plan`);
   console.log();
 }
@@ -5448,46 +6125,46 @@ async function logoutCommand() {
   console.log();
   const userData = await loadUserData();
   if (!userData.email) {
-    console.log(import_chalk13.default.dim("  Not signed in."));
+    console.log(import_chalk14.default.dim("  Not signed in."));
     console.log();
     return;
   }
   const email = userData.email;
   await saveUserData({ email: "", verified: false, tier: "free" });
-  console.log(import_chalk13.default.green(`  \u2713 Signed out (${email})`));
+  console.log(import_chalk14.default.green(`  \u2713 Signed out (${email})`));
   console.log();
 }
 
 // src/commands/record-cmd.ts
-var import_node_fs17 = require("fs");
-var import_promises17 = require("fs/promises");
-var import_node_path24 = require("path");
-var import_chalk18 = __toESM(require("chalk"));
+var import_node_fs19 = require("fs");
+var import_promises18 = require("fs/promises");
+var import_node_path25 = require("path");
+var import_chalk19 = __toESM(require("chalk"));
 init_lib();
 
 // src/commands/phases/auth-phase.ts
-var import_chalk15 = __toESM(require("chalk"));
+var import_chalk16 = __toESM(require("chalk"));
 init_lib();
 
 // src/commands/utils/auth-helpers.ts
-var import_chalk14 = __toESM(require("chalk"));
+var import_chalk15 = __toESM(require("chalk"));
 init_lib();
 async function handleRegistrationGate() {
   console.log();
-  console.log(import_chalk14.default.yellow("  \u{1F389} You've made 5 free videos!"));
-  console.log(import_chalk14.default.white("     Sign in to continue creating videos."));
+  console.log(import_chalk15.default.yellow("  \u{1F389} You've made 5 free videos!"));
+  console.log(import_chalk15.default.white("     Sign in to continue creating videos."));
   console.log();
-  console.log(import_chalk14.default.dim("  Benefits of signing in:"));
-  console.log(import_chalk14.default.dim("    \u2022 20 more videos per month"));
-  console.log(import_chalk14.default.dim("    \u2022 Keep your video history"));
-  console.log(import_chalk14.default.dim("    \u2022 Upgrade to Pro anytime"));
+  console.log(import_chalk15.default.dim("  Benefits of signing in:"));
+  console.log(import_chalk15.default.dim("    \u2022 20 more videos per month"));
+  console.log(import_chalk15.default.dim("    \u2022 Keep your video history"));
+  console.log(import_chalk15.default.dim("    \u2022 Upgrade to Pro anytime"));
   let email = await browserLogin();
   if (!email) {
     console.log();
     email = await promptInput("Email: ");
   }
   if (!email || !email.includes("@")) {
-    console.log(import_chalk14.default.red("  Invalid email. Run qp again to try again."));
+    console.log(import_chalk15.default.red("  Invalid email. Run qp again to try again."));
     return null;
   }
   const registerTask = task("Sending verification email");
@@ -5502,10 +6179,10 @@ async function handleRegistrationGate() {
   }
   registerTask.succeed("Check your email!");
   console.log();
-  console.log(import_chalk14.default.cyan("  \u{1F4E7} Verification email sent to:"));
-  console.log(import_chalk14.default.white(`     ${email}`));
+  console.log(import_chalk15.default.cyan("  \u{1F4E7} Verification email sent to:"));
+  console.log(import_chalk15.default.white(`     ${email}`));
   console.log();
-  console.log(import_chalk14.default.dim("  Click the link in the email, then press Enter to continue..."));
+  console.log(import_chalk15.default.dim("  Click the link in the email, then press Enter to continue..."));
   await promptInput("");
   const verifyTask = task("Checking verification");
   const verified = await isVerified(email);
@@ -5515,10 +6192,10 @@ async function handleRegistrationGate() {
   }
   verifyTask.fail("Not verified yet");
   console.log();
-  console.log(import_chalk14.default.yellow("  Email not verified. Check your inbox and spam folder."));
-  console.log(import_chalk14.default.dim("  Run qp again after clicking the verification link."));
+  console.log(import_chalk15.default.yellow("  Email not verified. Check your inbox and spam folder."));
+  console.log(import_chalk15.default.dim("  Run qp again after clicking the verification link."));
   console.log();
-  console.log(import_chalk14.default.cyan(`  Or register/upgrade at: ${getUpgradeUrl(email)}`));
+  console.log(import_chalk15.default.cyan(`  Or register/upgrade at: ${getUpgradeUrl(email)}`));
   console.log();
   return { email, verified: false };
 }
@@ -5546,7 +6223,7 @@ async function runAuthPhase(input) {
     } else {
       verifyTask.fail("Email not verified");
       console.log();
-      console.log(import_chalk15.default.yellow("  Check your inbox for the verification email."));
+      console.log(import_chalk16.default.yellow("  Check your inbox for the verification email."));
       console.log();
       const input2 = await promptInput(`New email or Enter to retry (${userEmail}): `);
       if (input2.toLowerCase() === "exit") {
@@ -5571,8 +6248,8 @@ async function runAuthPhase(input) {
           registerTask.succeed("Check your email!");
           await saveUserData({ email: newEmail, verified: false });
           console.log();
-          console.log(import_chalk15.default.cyan(`  \u{1F4E7} Verification sent to: ${newEmail}`));
-          console.log(import_chalk15.default.dim("  Click the link in the email, then run qp again."));
+          console.log(import_chalk16.default.cyan(`  \u{1F4E7} Verification sent to: ${newEmail}`));
+          console.log(import_chalk16.default.dim("  Click the link in the email, then run qp again."));
           console.log();
           gracefulExit();
           return null;
@@ -5588,7 +6265,7 @@ async function runAuthPhase(input) {
         } else {
           recheckTask.fail("Still not verified");
           console.log();
-          console.log(import_chalk15.default.cyan(`  Register/upgrade at: ${getUpgradeUrl(userEmail)}`));
+          console.log(import_chalk16.default.cyan(`  Register/upgrade at: ${getUpgradeUrl(userEmail)}`));
           console.log();
           gracefulExit();
           return null;
@@ -5615,8 +6292,8 @@ async function runAuthPhase(input) {
   } else {
     const remaining = FREE_VIDEO_LIMIT - localVideoCount;
     console.log();
-    console.log(import_chalk15.default.cyan(`  \u{1F3AC} Video ${localVideoCount + 1}/${FREE_VIDEO_LIMIT} free`));
-    console.log(import_chalk15.default.dim(`     ${remaining - 1} more after this \u2022 Sign up for unlimited`));
+    console.log(import_chalk16.default.cyan(`  \u{1F3AC} Video ${localVideoCount + 1}/${FREE_VIDEO_LIMIT} free`));
+    console.log(import_chalk16.default.dim(`     ${remaining - 1} more after this \u2022 Sign up for unlimited`));
     userEmail = await setupUserEmail();
     let registeredVerified = false;
     try {
@@ -5635,18 +6312,18 @@ async function runAuthPhase(input) {
 }
 
 // src/commands/phases/plan-phase.ts
-var import_node_fs15 = require("fs");
-var import_promises15 = require("fs/promises");
-var import_node_path22 = require("path");
-var import_chalk16 = __toESM(require("chalk"));
+var import_node_fs17 = require("fs");
+var import_promises16 = require("fs/promises");
+var import_node_path23 = require("path");
+var import_chalk17 = __toESM(require("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;
@@ -5770,10 +6447,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;
@@ -5790,14 +6472,24 @@ Return ONLY JSON: {"description": "...", "captions": ["...", ...]}`;
 // src/commands/phases/plan-phase.ts
 var INDENT6 = "   ";
 async function runPlanPhase(params) {
-  const { url, config, userEmail, description, planPath, legacyPlanPath, targetLang, userTier = "free" } = params;
+  const {
+    url,
+    config,
+    userEmail,
+    description,
+    planPath,
+    legacyPlanPath,
+    targetLang,
+    userTier = "free",
+    fresh = false
+  } = params;
   const maxSteps = config.plan?.maxSteps ?? 8;
   const extensionPath = config.browser?.extension;
   let existingPlan = null;
   let existingPlanPath = null;
-  if ((0, import_node_fs15.existsSync)(planPath)) {
+  if ((0, import_node_fs17.existsSync)(planPath)) {
     try {
-      const parsed = JSON.parse(await (0, import_promises15.readFile)(planPath, "utf-8"));
+      const parsed = JSON.parse(await (0, import_promises16.readFile)(planPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
         existingPlan = parsed;
         existingPlanPath = planPath;
@@ -5807,12 +6499,12 @@ async function runPlanPhase(params) {
   }
   if (!existingPlan) {
     try {
-      const files = (0, import_node_fs15.readdirSync)(config.output.dir);
-      const planFiles = files.filter((f) => /^plan-[a-z]{2}(-[A-Z]{2})?\.json$/.test(f) && f !== (0, import_node_path22.basename)(planPath));
+      const files = (0, import_node_fs17.readdirSync)(config.output.dir);
+      const planFiles = files.filter((f) => /^plan-[a-z]{2}(-[A-Z]{2})?\.json$/.test(f) && f !== (0, import_node_path23.basename)(planPath));
       for (const file of planFiles) {
-        const filePath = (0, import_node_path22.join)(config.output.dir, file);
+        const filePath = (0, import_node_path23.join)(config.output.dir, file);
         try {
-          const parsed = JSON.parse(await (0, import_promises15.readFile)(filePath, "utf-8"));
+          const parsed = JSON.parse(await (0, import_promises16.readFile)(filePath, "utf-8"));
           if (parsed.url && parsed.steps?.length > 0) {
             existingPlan = parsed;
             existingPlanPath = filePath;
@@ -5824,9 +6516,9 @@ async function runPlanPhase(params) {
     } catch {
     }
   }
-  if (!existingPlan && (0, import_node_fs15.existsSync)(legacyPlanPath)) {
+  if (!existingPlan && (0, import_node_fs17.existsSync)(legacyPlanPath)) {
     try {
-      const parsed = JSON.parse(await (0, import_promises15.readFile)(legacyPlanPath, "utf-8"));
+      const parsed = JSON.parse(await (0, import_promises16.readFile)(legacyPlanPath, "utf-8"));
       if (parsed.url && parsed.steps?.length > 0) {
         existingPlan = parsed;
         existingPlanPath = legacyPlanPath;
@@ -5836,6 +6528,11 @@ async function runPlanPhase(params) {
   }
   const normalizeUrl4 = (u) => u.replace(/\/+$/, "").toLowerCase();
   const urlMatches = existingPlan && normalizeUrl4(existingPlan.url) === normalizeUrl4(url);
+  if (existingPlan && !urlMatches && isAutoYes()) {
+    console.log();
+    console.log(import_chalk17.default.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}`);
@@ -5850,25 +6547,25 @@ async function runPlanPhase(params) {
       translateTask.fail(failMsg);
     }
   };
-  if (existingPlan && existingPlanPath) {
+  if (existingPlan && existingPlanPath && !fresh) {
     console.log();
-    console.log(import_chalk16.default.dim(`  Found existing plan: `) + import_chalk16.default.cyan(formatClickablePath(existingPlanPath)));
-    console.log(import_chalk16.default.dim(`  ${existingPlan.steps.length} steps for ${existingPlan.url}`));
+    console.log(import_chalk17.default.dim(`  Found existing plan: `) + import_chalk17.default.cyan(formatClickablePath(existingPlanPath)));
+    console.log(import_chalk17.default.dim(`  ${existingPlan.steps.length} steps for ${existingPlan.url}`));
     if (!urlMatches) {
-      console.log(import_chalk16.default.yellow(`  \u26A0 Plan URL differs from argument:`));
-      console.log(import_chalk16.default.yellow(`    Plan: ${existingPlan.url}`));
-      console.log(import_chalk16.default.yellow(`    Arg:  ${url}`));
+      console.log(import_chalk17.default.yellow(`  \u26A0 Plan URL differs from argument:`));
+      console.log(import_chalk17.default.yellow(`    Plan: ${existingPlan.url}`));
+      console.log(import_chalk17.default.yellow(`    Arg:  ${url}`));
     }
     const existingLang = existingPlan.lang || "en";
     if (existingLang !== targetLang) {
-      console.log(import_chalk16.default.yellow(`  \u26A0 Plan is in ${existingLang}, config is ${targetLang}`));
+      console.log(import_chalk17.default.yellow(`  \u26A0 Plan is in ${existingLang}, config is ${targetLang}`));
     }
     const reuse = await confirm(`${INDENT6}Use existing plan?`);
     if (reuse) {
       plan = await validateAndFixPlan(existingPlanPath, task, logError, userEmail, userTier);
       if (existingPlanPath !== planPath) {
         await savePlan(plan, planPath);
-        console.log(import_chalk16.default.dim(`  Migrated to: ${formatClickablePath(planPath)}`));
+        console.log(import_chalk17.default.dim(`  Migrated to: ${formatClickablePath(planPath)}`));
       }
       if (existingLang !== targetLang) {
         const translate = await confirm(`${INDENT6}Translate to ${targetLang}?`);
@@ -5886,7 +6583,8 @@ async function runPlanPhase(params) {
         userEmail,
         extensionPath,
         config.output.dir,
-        userTier
+        userTier,
+        { width: config.video.width, height: config.video.height }
       );
       displayRateLimitInfo();
       if (urlMatches) {
@@ -5903,7 +6601,7 @@ async function runPlanPhase(params) {
             uploadIdx++;
           }
         }
-        console.log(import_chalk16.default.dim(`  Preserved upload paths from previous plan`));
+        console.log(import_chalk17.default.dim(`  Preserved upload paths from previous plan`));
       }
       await savePlan(plan, planPath);
       plan = await validateAndFixPlan(planPath, task, logError, userEmail, userTier);
@@ -5919,7 +6617,9 @@ async function runPlanPhase(params) {
       logError,
       userEmail,
       extensionPath,
-      config.output.dir
+      config.output.dir,
+      void 0,
+      { width: config.video.width, height: config.video.height }
     );
     displayRateLimitInfo();
     await savePlan(plan, planPath);
@@ -5927,8 +6627,8 @@ async function runPlanPhase(params) {
   }
   displayPlanSummary(plan);
   console.log();
-  console.log(import_chalk16.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
-  console.log(import_chalk16.default.dim(`  Enter a prompt to refine, or press Enter to continue.`));
+  console.log(import_chalk17.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
+  console.log(import_chalk17.default.dim(`  Enter a prompt to refine, or press Enter to continue.`));
   const MAX_REFINEMENTS = 10;
   let refinementCount = 0;
   while (true) {
@@ -5946,15 +6646,15 @@ async function runPlanPhase(params) {
       refineTask.succeed("Plan refined");
       displayRateLimitInfo();
       if (plan.steps.length > maxSteps) {
-        console.log(import_chalk16.default.yellow(`  \u26A0 ${plan.steps.length} steps exceeds limit of ${maxSteps}`));
+        console.log(import_chalk17.default.yellow(`  \u26A0 ${plan.steps.length} steps exceeds limit of ${maxSteps}`));
       }
       displayPlanSummary(plan);
       console.log();
-      console.log(import_chalk16.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
+      console.log(import_chalk17.default.dim(`  Plan: ${formatClickablePath(planPath)}`));
       if (refinementCount >= MAX_REFINEMENTS) {
         console.log();
-        console.log(import_chalk16.default.yellow(`  \u26A0 You've refined the plan ${MAX_REFINEMENTS} times.`));
-        console.log(import_chalk16.default.dim(`  Further refinements may incur additional costs.`));
+        console.log(import_chalk17.default.yellow(`  \u26A0 You've refined the plan ${MAX_REFINEMENTS} times.`));
+        console.log(import_chalk17.default.dim(`  Further refinements may incur additional costs.`));
         const continueRefining = await confirm(`${INDENT6}Continue refining?`);
         if (!continueRefining) break;
       }
@@ -5966,12 +6666,12 @@ async function runPlanPhase(params) {
   const planLang = plan.lang || "en";
   if (planLang !== targetLang) {
     let useExistingTranslation = false;
-    if ((0, import_node_fs15.existsSync)(planPath) && existingPlanPath !== planPath) {
+    if ((0, import_node_fs17.existsSync)(planPath) && existingPlanPath !== planPath) {
       try {
-        const translatedPlan = JSON.parse(await (0, import_promises15.readFile)(planPath, "utf-8"));
+        const translatedPlan = JSON.parse(await (0, import_promises16.readFile)(planPath, "utf-8"));
         if (translatedPlan.steps?.length === plan.steps.length && translatedPlan.lang === targetLang) {
           console.log();
-          console.log(import_chalk16.default.dim(`  Found translated plan: ${formatClickablePath(planPath)}`));
+          console.log(import_chalk17.default.dim(`  Found translated plan: ${formatClickablePath(planPath)}`));
           const useTranslated = await confirm(`${INDENT6}Use ${targetLang} translation?`);
           if (useTranslated) {
             plan = translatedPlan;
@@ -5983,7 +6683,7 @@ async function runPlanPhase(params) {
     }
     if (!useExistingTranslation) {
       console.log();
-      console.log(import_chalk16.default.yellow(`  Plan is in ${planLang}, but voice is set to ${targetLang}`));
+      console.log(import_chalk17.default.yellow(`  Plan is in ${planLang}, but voice is set to ${targetLang}`));
       const translate = await confirm(`${INDENT6}Translate captions to ${targetLang}?`);
       if (translate) await doTranslate("Translation failed, using original");
     }
@@ -5992,8 +6692,8 @@ async function runPlanPhase(params) {
 }
 
 // src/commands/phases/validation-phase.ts
-var import_promises16 = require("fs/promises");
-var import_chalk17 = __toESM(require("chalk"));
+var import_promises17 = require("fs/promises");
+var import_chalk18 = __toESM(require("chalk"));
 async function runValidationPhase(params) {
   let { plan } = params;
   const { config, planPath, isExtensionUrl, userEmail, userTier = "free" } = params;
@@ -6044,21 +6744,21 @@ async function runValidationPhase(params) {
     const stepNum = result.stepIndex + 1;
     const step = plan.steps[result.stepIndex];
     console.log();
-    console.log(import_chalk17.default.red(`  \u2717 Step ${stepNum}: ${step.action}`));
+    console.log(import_chalk18.default.red(`  \u2717 Step ${stepNum}: ${step.action}`));
     const caption = step.caption || "";
-    if (caption) console.log(import_chalk17.default.dim(`    Caption: ${caption.slice(0, 50)}${caption.length > 50 ? "..." : ""}`));
-    console.log(import_chalk17.default.dim(`    Target: ${step.target || "none"}`));
-    if (step.value) console.log(import_chalk17.default.dim(`    Value: ${step.value}`));
-    console.log(import_chalk17.default.dim(`    Error: ${result.error}`));
+    if (caption) console.log(import_chalk18.default.dim(`    Caption: ${caption.slice(0, 50)}${caption.length > 50 ? "..." : ""}`));
+    console.log(import_chalk18.default.dim(`    Target: ${step.target || "none"}`));
+    if (step.value) console.log(import_chalk18.default.dim(`    Value: ${step.value}`));
+    console.log(import_chalk18.default.dim(`    Error: ${result.error}`));
     if (result.suggestion) {
-      console.log(import_chalk17.default.yellow(`    Hint: ${result.suggestion}`));
+      console.log(import_chalk18.default.yellow(`    Hint: ${result.suggestion}`));
     }
     console.log();
     const isUploadMissingFile = step.action === "upload" && (!step.value || step.value.startsWith("[") || step.value.includes("example") || step.value.includes("/path/to"));
     if (isUploadMissingFile) {
       const filePath = await promptInput('Enter file path to upload (or "skip"): ');
       if (filePath.toLowerCase() === "skip") {
-        console.log(import_chalk17.default.yellow(`  Skipping step ${stepNum}`));
+        console.log(import_chalk18.default.yellow(`  Skipping step ${stepNum}`));
         continue;
       }
       if (filePath) {
@@ -6067,13 +6767,13 @@ async function runValidationPhase(params) {
         const revalidation2 = await validateStepsOnPage(plan, config, logError, config.output.dir);
         const newResult2 = revalidation2.results[result.stepIndex];
         if (newResult2?.success) {
-          console.log(import_chalk17.default.green(`  \u2713 Step ${stepNum} now passes`));
+          console.log(import_chalk18.default.green(`  \u2713 Step ${stepNum} now passes`));
           validationResult = revalidation2;
           continue;
         }
         result.error = newResult2?.error;
         result.suggestion = newResult2?.suggestion;
-        console.log(import_chalk17.default.red(`  Still failing: ${result.error}`));
+        console.log(import_chalk18.default.red(`  Still failing: ${result.error}`));
       }
     }
     const fixTask = task(`Fixing step ${stepNum} with AI`);
@@ -6095,8 +6795,8 @@ async function runValidationPhase(params) {
       await savePlan(plan, planPath);
       fixTask.succeed("AI suggested a fix");
       const fixedStep = plan.steps[result.stepIndex];
-      console.log(import_chalk17.default.dim(`    New target: ${fixedStep.target || "none"}`));
-      if (fixedStep.value) console.log(import_chalk17.default.dim(`    New value: ${fixedStep.value}`));
+      console.log(import_chalk18.default.dim(`    New target: ${fixedStep.target || "none"}`));
+      if (fixedStep.value) console.log(import_chalk18.default.dim(`    New value: ${fixedStep.value}`));
     } catch {
       fixTask.fail("AI could not fix automatically");
     }
@@ -6112,14 +6812,14 @@ async function runValidationPhase(params) {
     result.error = newResult?.error;
     result.suggestion = newResult?.suggestion;
     console.log();
-    console.log(import_chalk17.default.yellow(`  Edit step ${stepNum} in: `) + import_chalk17.default.cyan(formatClickablePath(planPath)));
+    console.log(import_chalk18.default.yellow(`  Edit step ${stepNum} in: `) + import_chalk18.default.cyan(formatClickablePath(planPath)));
     console.log();
     const choice = await promptInput('Press Enter after editing, or type "skip" to skip this step: ');
     if (choice.toLowerCase() === "skip") {
-      console.log(import_chalk17.default.yellow(`  Skipping step ${stepNum} - may fail during recording`));
+      console.log(import_chalk18.default.yellow(`  Skipping step ${stepNum} - may fail during recording`));
       continue;
     }
-    plan = JSON.parse(await (0, import_promises16.readFile)(planPath, "utf-8"));
+    plan = JSON.parse(await (0, import_promises17.readFile)(planPath, "utf-8"));
     const finalRevalidateTask = task(`Final validation of step ${stepNum}`);
     const finalRevalidation = await validateStepsOnPage(plan, config, logError, config.output.dir);
     const finalResult = finalRevalidation.results[result.stepIndex];
@@ -6143,31 +6843,31 @@ async function runValidationPhase(params) {
 }
 
 // src/commands/utils/chrome-extension.ts
-var import_node_fs16 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_os3 = require("os");
-var import_node_path23 = require("path");
+var import_node_path24 = require("path");
 function resolveChromeExtension(extensionId) {
   const platform = process.platform;
   const possibleDirs = [];
   const getChromeExtDirs = (userDataPath) => {
     const dirs = [];
     try {
-      const profiles = (0, import_node_fs16.readdirSync)(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
+      const profiles = (0, import_node_fs18.readdirSync)(userDataPath).filter((p) => p === "Default" || p.startsWith("Profile "));
       for (const profile of profiles) {
-        dirs.push((0, import_node_path23.join)(userDataPath, profile, "Extensions"));
+        dirs.push((0, import_node_path24.join)(userDataPath, profile, "Extensions"));
       }
     } catch {
-      dirs.push((0, import_node_path23.join)(userDataPath, "Default", "Extensions"));
+      dirs.push((0, import_node_path24.join)(userDataPath, "Default", "Extensions"));
     }
     return dirs;
   };
   if (platform === "win32") {
-    possibleDirs.push(...getChromeExtDirs((0, import_node_path23.join)((0, import_node_os3.homedir)(), "AppData", "Local", "Google", "Chrome", "User Data")));
+    possibleDirs.push(...getChromeExtDirs((0, import_node_path24.join)((0, import_node_os3.homedir)(), "AppData", "Local", "Google", "Chrome", "User Data")));
   } else if (platform === "darwin") {
-    possibleDirs.push(...getChromeExtDirs((0, import_node_path23.join)((0, import_node_os3.homedir)(), "Library", "Application Support", "Google", "Chrome")));
+    possibleDirs.push(...getChromeExtDirs((0, import_node_path24.join)((0, import_node_os3.homedir)(), "Library", "Application Support", "Google", "Chrome")));
   } else {
     try {
-      const windowsUsers = (0, import_node_fs16.readdirSync)("/mnt/c/Users").filter(
+      const windowsUsers = (0, import_node_fs18.readdirSync)("/mnt/c/Users").filter(
         (u) => !["All Users", "Default", "Default User", "Public", "desktop.ini"].includes(u)
       );
       for (const user of windowsUsers) {
@@ -6175,22 +6875,22 @@ function resolveChromeExtension(extensionId) {
       }
     } catch {
     }
-    possibleDirs.push(...getChromeExtDirs((0, import_node_path23.join)((0, import_node_os3.homedir)(), ".config", "google-chrome")));
+    possibleDirs.push(...getChromeExtDirs((0, import_node_path24.join)((0, import_node_os3.homedir)(), ".config", "google-chrome")));
   }
   for (const chromeExtDir of possibleDirs) {
-    const extDir = (0, import_node_path23.join)(chromeExtDir, extensionId);
-    if (!(0, import_node_fs16.existsSync)(extDir)) continue;
+    const extDir = (0, import_node_path24.join)(chromeExtDir, extensionId);
+    if (!(0, import_node_fs18.existsSync)(extDir)) continue;
     try {
-      const versions = (0, import_node_fs16.readdirSync)(extDir).filter((f) => !f.startsWith("."));
+      const versions = (0, import_node_fs18.readdirSync)(extDir).filter((f) => !f.startsWith("."));
       if (versions.length === 0) continue;
       const latestVersion = versions.sort().pop();
-      const extPath = (0, import_node_path23.join)(extDir, latestVersion);
+      const extPath = (0, import_node_path24.join)(extDir, latestVersion);
       let name = extensionId;
       let popupPath = "popup.html";
-      const manifestPath = (0, import_node_path23.join)(extPath, "manifest.json");
-      if ((0, import_node_fs16.existsSync)(manifestPath)) {
+      const manifestPath = (0, import_node_path24.join)(extPath, "manifest.json");
+      if ((0, import_node_fs18.existsSync)(manifestPath)) {
         try {
-          const manifest = JSON.parse((0, import_node_fs16.readFileSync)(manifestPath, "utf-8"));
+          const manifest = JSON.parse((0, import_node_fs18.readFileSync)(manifestPath, "utf-8"));
           if (manifest.name && !manifest.name.startsWith("__MSG_")) {
             name = manifest.name;
           }
@@ -6221,16 +6921,23 @@ async function recordCommand(url, options = {}) {
     const extensionId = url.slice(7);
     chromeExtension = resolveChromeExtension(extensionId);
     if (!chromeExtension) {
-      console.log(import_chalk18.default.red(`
+      console.log(import_chalk19.default.red(`
   \u2717 Chrome extension not found: ${extensionId}`));
-      console.log(import_chalk18.default.dim(`    Make sure the extension is installed in Chrome
+      console.log(import_chalk19.default.dim(`    Make sure the extension is installed in Chrome
 `));
       process.exit(1);
     }
     config.browser = { extension: chromeExtension.path };
     url = chromeExtension.popupUrl;
-    console.log(import_chalk18.default.dim(`  Extension: ${chromeExtension.name}`));
-    console.log(import_chalk18.default.dim(`  Path: ${chromeExtension.path}`));
+    console.log(import_chalk19.default.dim(`  Extension: ${chromeExtension.name}`));
+    console.log(import_chalk19.default.dim(`  Path: ${chromeExtension.path}`));
+  }
+  if (!chromeExtension) {
+    const startUrl = resolveStartUrl(url);
+    if (startUrl !== url) {
+      console.log(import_chalk19.default.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();
@@ -6243,20 +6950,20 @@ async function recordCommand(url, options = {}) {
   if (!authResult) return;
   const { userEmail, userTier, localVideoCount } = authResult;
   if (configCreated) {
-    const configPath = (0, import_node_path24.join)(process.cwd(), CONFIG_FILE);
+    const configPath = (0, import_node_path25.join)(process.cwd(), CONFIG_FILE);
     console.log();
-    console.log(import_chalk18.default.green(`  \u2714 Created ${CONFIG_FILE}`));
-    console.log(import_chalk18.default.dim(`    ${configPath}`));
+    console.log(import_chalk19.default.green(`  \u2714 Created ${CONFIG_FILE}`));
+    console.log(import_chalk19.default.dim(`    ${configPath}`));
     console.log();
-    console.log(import_chalk18.default.cyan("  Review the config file to customize:"));
-    console.log(import_chalk18.default.dim("    \u2022 lang: Voice language (en, es, ar, zh...)"));
-    console.log(import_chalk18.default.dim("    \u2022 video: Resolution, quality, effects"));
-    console.log(import_chalk18.default.dim("    \u2022 music: Background music path and volume"));
-    console.log(import_chalk18.default.dim("    \u2022 output: Output directory"));
+    console.log(import_chalk19.default.cyan("  Review the config file to customize:"));
+    console.log(import_chalk19.default.dim("    \u2022 lang: Voice language (en, es, ar, zh...)"));
+    console.log(import_chalk19.default.dim("    \u2022 video: Resolution, quality, effects"));
+    console.log(import_chalk19.default.dim("    \u2022 music: Background music path and volume"));
+    console.log(import_chalk19.default.dim("    \u2022 output: Output directory"));
     console.log();
     const proceed = await confirm(`${INDENT3}Proceed with default settings?`);
     if (!proceed) {
-      console.log(import_chalk18.default.yellow(`
+      console.log(import_chalk19.default.yellow(`
   Edit ${CONFIG_FILE} and run again.
 `));
       process.exit(0);
@@ -6264,17 +6971,17 @@ async function recordCommand(url, options = {}) {
   }
   if (langOverride) config.lang = langOverride;
   if (config.music?.path) {
-    const musicPath = (0, import_node_path24.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path24.resolve)(config.output.dir, config.music.path);
-    if (!(0, import_node_fs17.existsSync)(musicPath)) {
+    const musicPath = (0, import_node_path25.isAbsolute)(config.music.path) ? config.music.path : (0, import_node_path25.resolve)(config.output.dir, config.music.path);
+    if (!(0, import_node_fs19.existsSync)(musicPath)) {
       console.log();
-      console.log(import_chalk18.default.yellow(`  \u26A0 Music file not found: ${config.music.path}`));
-      console.log(import_chalk18.default.dim(`    Config: ${(0, import_node_path24.join)(process.cwd(), CONFIG_FILE)}`));
+      console.log(import_chalk19.default.yellow(`  \u26A0 Music file not found: ${config.music.path}`));
+      console.log(import_chalk19.default.dim(`    Config: ${(0, import_node_path25.join)(process.cwd(), CONFIG_FILE)}`));
       console.log();
       const proceed = await confirm(`${INDENT3}Continue without background music?`);
       if (!proceed) {
-        console.log(import_chalk18.default.yellow(`
+        console.log(import_chalk19.default.yellow(`
   Edit music.path in config and run again.`));
-        console.log(import_chalk18.default.dim(`    ${(0, import_node_path24.join)(process.cwd(), CONFIG_FILE)}
+        console.log(import_chalk19.default.dim(`    ${(0, import_node_path25.join)(process.cwd(), CONFIG_FILE)}
 `));
         process.exit(0);
       }
@@ -6284,10 +6991,10 @@ async function recordCommand(url, options = {}) {
   const captions = await loadCaptions();
   const workDir = await prepareWorkDir();
   const targetLang = config.lang || "en";
-  const planPath = (0, import_node_path24.join)(config.output.dir, `plan-${targetLang}.json`);
-  const legacyPlanPath = (0, import_node_path24.join)(config.output.dir, "plan.json");
+  const planPath = (0, import_node_path25.join)(config.output.dir, `plan-${targetLang}.json`);
+  const legacyPlanPath = (0, import_node_path25.join)(config.output.dir, "plan.json");
   const isExtensionUrl = url.startsWith("chrome-extension://");
-  await (0, import_promises17.mkdir)(config.output.dir, { recursive: true });
+  await (0, import_promises18.mkdir)(config.output.dir, { recursive: true });
   await setLogFilePath(config.output.dir);
   try {
     const plan = await runPlanPhase({
@@ -6298,7 +7005,8 @@ async function recordCommand(url, options = {}) {
       ...description !== void 0 && { description },
       planPath,
       legacyPlanPath,
-      targetLang
+      targetLang,
+      ...fresh !== void 0 && { fresh }
     });
     const validatedPlan = await runValidationPhase({
       plan,
@@ -6323,51 +7031,87 @@ async function recordCommand(url, options = {}) {
       await saveUserData({ localVideoCount: newCount });
       const remaining = FREE_VIDEO_LIMIT - newCount;
       if (remaining > 0) {
-        console.log(import_chalk18.default.dim(`  ${remaining} free video${remaining === 1 ? "" : "s"} remaining`));
+        console.log(import_chalk19.default.dim(`  ${remaining} free video${remaining === 1 ? "" : "s"} remaining`));
       }
     }
     console.log();
-    console.log(import_chalk18.default.bold.green("  \u2713 Done!"));
+    console.log(import_chalk19.default.bold.green("  \u2713 Done!"));
     console.log();
-    console.log(import_chalk18.default.cyan(`  ${formatClickablePath(finalPath)}`));
+    console.log(import_chalk19.default.cyan(`  ${formatClickablePath(finalPath)}`));
     console.log();
     return finalPath;
   } catch (err) {
     await logError("Record Command", err);
     if (rethrow) throw err;
     console.log();
-    console.log(import_chalk18.default.red(`  Error: ${err instanceof Error ? err.message : "Unknown error"}`));
-    console.log(import_chalk18.default.dim(`  See ${logFilePath} for details`));
+    console.log(import_chalk19.default.red(`  Error: ${err instanceof Error ? err.message : "Unknown error"}`));
+    console.log(import_chalk19.default.dim(`  See ${logFilePath} for details`));
     process.exit(1);
   }
 }
 
 // src/commands/script-cmd.ts
-var import_promises18 = require("fs/promises");
-var import_node_path25 = require("path");
-var import_chalk19 = __toESM(require("chalk"));
+var import_promises19 = require("fs/promises");
+var import_node_path26 = require("path");
+var import_chalk20 = __toESM(require("chalk"));
 init_lib();
+async function reusablePlan(planPath, lines) {
+  try {
+    const plan = JSON.parse(await (0, import_promises19.readFile)(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 (0, import_promises18.readFile)(scriptPath, "utf-8");
+  const raw = await (0, import_promises19.readFile)(scriptPath, "utf-8");
   const lines = raw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
   if (lines.length === 0) {
-    console.log(import_chalk19.default.red("  Script file is empty or has no non-comment lines"));
+    console.log(import_chalk20.default.red("  Script file is empty or has no non-comment lines"));
     process.exit(1);
   }
   info(`${lines.length} captions from script`);
+  const maxSteps = config.plan?.maxSteps ?? 8;
+  if (lines.length > maxSteps) {
+    console.log(
+      import_chalk20.default.yellow(`  \u26A0 ${lines.length} script lines exceeds plan.maxSteps (${maxSteps}) \u2014 recording all of them.`)
+    );
+    console.log(import_chalk20.default.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 = (0, import_node_path25.join)(config.output.dir, `plan-${lang ?? "en"}.json`);
-  await savePlan(plan, planPath);
-  planTask.succeed(`${plan.steps.length} steps planned`);
+  const planPath = (0, import_node_path26.join)(config.output.dir, `plan-${lang ?? "en"}.json`);
+  let plan = await reusablePlan(planPath, lines);
+  if (plan) {
+    planTask.succeed(`${plan.steps.length} steps reused from existing plan`);
+  } else {
+    plan = await generatePlanFromScript(
+      lines,
+      url,
+      appTitle,
+      elementsText,
+      lang,
+      logError,
+      userData.email,
+      userTier,
+      () => planTask
+    );
+    await savePlan(plan, planPath);
+    planTask.succeed(`${plan.steps.length} steps planned`);
+  }
   header("Voiceover");
   const { voiceoverPath, stepAudio } = await generateVoiceover(
     plan.steps,
@@ -6383,10 +7127,10 @@ 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(import_chalk19.default.bold.green("  Done!"));
-  console.log(import_chalk19.default.cyan(`  ${finalPath}`));
+  console.log(import_chalk20.default.bold.green("  Done!"));
+  console.log(import_chalk20.default.cyan(`  ${finalPath}`));
 }
 
 // src/qp.ts
@@ -6456,6 +7200,20 @@ function parseArgs(args) {
   if (first === "record") {
     args = args.slice(1);
   }
+  if (first === "edit") {
+    const rest = args.slice(1);
+    let url2;
+    let lang2;
+    for (const arg2 of rest) {
+      if (arg2.startsWith("lang=")) {
+        lang2 = arg2.slice(5);
+      } else if (!arg2.startsWith("-") && !url2 && !arg2.includes("=")) {
+        url2 = normalizeUrl3(arg2);
+      }
+    }
+    if (!url2) return { ...base, command: "help" };
+    return { ...base, command: "edit", url: url2, lang: lang2 };
+  }
   if (first === "capture") {
     const rest = args.slice(1);
     let url2;
@@ -6479,7 +7237,9 @@ function parseArgs(args) {
   let fresh = false;
   for (let i = 0; i < args.length; i++) {
     const arg2 = args[i];
-    if (arg2.startsWith("lang=")) {
+    if (!url && (arg2.startsWith("http://") || arg2.startsWith("https://"))) {
+      url = normalizeUrl3(arg2);
+    } else if (arg2.startsWith("lang=")) {
       lang = arg2.slice(5);
     } else if (arg2 === "--script" || arg2 === "-s") {
       scriptPath = args[i + 1];
@@ -6523,8 +7283,8 @@ async function main() {
       break;
     case "auth":
       if (!parsed.url) {
-        console.log(import_chalk20.default.red("  Missing URL"));
-        console.log(import_chalk20.default.dim("  Run: qp auth <url>"));
+        console.log(import_chalk21.default.red("  Missing URL"));
+        console.log(import_chalk21.default.dim("  Run: qp auth <url>"));
         process.exit(1);
       }
       await authCommand(parsed.url);
@@ -6535,6 +7295,14 @@ async function main() {
     case "auth-list":
       await authListCommand();
       break;
+    case "edit":
+      if (!parsed.url) {
+        console.log(import_chalk21.default.red("  Missing URL"));
+        console.log(import_chalk21.default.dim("  Run: qp edit <url>"));
+        process.exit(1);
+      }
+      await editCommand(parsed.url, parsed.lang);
+      break;
     case "init":
       await initCommand();
       break;
@@ -6543,8 +7311,8 @@ async function main() {
       break;
     case "record":
       if (!parsed.url) {
-        console.log(import_chalk20.default.red("  Missing URL"));
-        console.log(import_chalk20.default.dim("  Run: qp --help"));
+        console.log(import_chalk21.default.red("  Missing URL"));
+        console.log(import_chalk21.default.dim("  Run: qp --help"));
         process.exit(1);
       }
       setAutoYes(parsed.yes);
@@ -6563,8 +7331,8 @@ async function main() {
       break;
     case "capture":
       if (!parsed.url) {
-        console.log(import_chalk20.default.red("  Missing URL"));
-        console.log(import_chalk20.default.dim("  Run: qp --help"));
+        console.log(import_chalk21.default.red("  Missing URL"));
+        console.log(import_chalk21.default.dim("  Run: qp --help"));
         process.exit(1);
       }
       console.log();