@xbrowser/cli 1.0.0 → 1.0.3

package/dist/chunk-2SVQTI2O.js

@@ -0,0 +1,2794 @@
+import {
+  __esm,
+  __export,
+  __require,
+  __toCommonJS
+} from "./chunk-KFQGP6VL.js";
+
+// src/recorder/site-knowledge.ts
+var site_knowledge_exports = {};
+__export(site_knowledge_exports, {
+  addKnownIssue: () => addKnownIssue,
+  getKnowledgeDir: () => getKnowledgeDir,
+  getKnowledgePath: () => getKnowledgePath,
+  listSiteKnowledge: () => listSiteKnowledge,
+  readSiteKnowledge: () => readSiteKnowledge,
+  readSiteKnowledgeMarkdown: () => readSiteKnowledgeMarkdown,
+  toMarkdown: () => toMarkdown,
+  updateSiteKnowledge: () => updateSiteKnowledge
+});
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getKnowledgeDir() {
+  return join(homedir(), ".xbrowser", "knowledge");
+}
+function getKnowledgePath(domain, ext) {
+  return join(getKnowledgeDir(), `${domain}.${ext}`);
+}
+function extractDomain(url) {
+  try {
+    const u = new URL(url);
+    return u.hostname.replace(/^www\./, "");
+  } catch {
+    return "unknown";
+  }
+}
+function normalizePath(url) {
+  try {
+    const u = new URL(url);
+    return u.pathname;
+  } catch {
+    return url;
+  }
+}
+function extractSelectors(actions, pageUrl) {
+  const seen = /* @__PURE__ */ new Map();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const action of actions) {
+    if (normalizePath(action.url) !== normalizePath(pageUrl)) continue;
+    const el = action.element;
+    if (!el || !el.selector) continue;
+    const key = el.selector;
+    const existing = seen.get(key);
+    if (existing) {
+      existing.timesSeen++;
+      existing.lastSeen = now;
+    } else {
+      const description = buildDescription(el, action);
+      seen.set(key, {
+        selector: key,
+        tag: el.tag || "unknown",
+        description,
+        actionType: action.type,
+        role: el.role,
+        text: el.text?.substring(0, 60),
+        confidence: el.confidence || "medium",
+        lastSeen: now,
+        timesSeen: 1,
+        status: "active"
+      });
+    }
+  }
+  return Array.from(seen.values()).sort((a, b) => b.timesSeen - a.timesSeen);
+}
+function buildDescription(el, action) {
+  const parts = [];
+  if (el.text) parts.push(`"${el.text}"`);
+  if (el.placeholder) parts.push(`placeholder="${el.placeholder}"`);
+  if (el.ariaLabel) parts.push(`aria-label="${el.ariaLabel}"`);
+  if (el.role) parts.push(`role=${el.role}`);
+  if (el.type) parts.push(`type=${el.type}`);
+  const actionDesc = {
+    click: "clicked",
+    input: `filled with "${action.value?.substring(0, 30)}"`,
+    change: "changed",
+    submit: "submitted form",
+    dblclick: "double-clicked",
+    contextmenu: "right-clicked",
+    hover: "hovered over",
+    focus: "focused"
+  };
+  const verb = actionDesc[action.type] || action.type;
+  const base = parts.length > 0 ? parts.join(", ") : el.tag || "element";
+  return `${base} \u2014 ${verb}`;
+}
+function extractForms(actions, pageUrl) {
+  const forms = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    if (normalizePath(action.url) !== normalizePath(pageUrl)) continue;
+    const el = action.element;
+    if (!el) continue;
+    if (el.tag === "input" || el.tag === "textarea" || el.tag === "select") {
+      const formKey = "main";
+      const form = forms.get(formKey) || {
+        name: "Main Form",
+        action: pageUrl,
+        fields: []
+      };
+      if (!form.fields.some((f) => f.selector === el.selector)) {
+        form.fields.push({
+          selector: el.selector || "",
+          tag: el.tag,
+          label: el.ariaLabel || el.placeholder || el.text || el.selector || "",
+          inputType: el.type || el.tag,
+          placeholder: el.placeholder
+        });
+      }
+      forms.set(formKey, form);
+    }
+    if (action.type === "submit" || action.type === "click" && el.tag === "button" && el.text) {
+      const form = forms.get("main");
+      if (form && !form.submitSelector) {
+        form.submitSelector = el.selector;
+      }
+    }
+  }
+  return Array.from(forms.values());
+}
+function extractNavLinks(actions) {
+  const links = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const action of actions) {
+    if (action.type !== "click" && action.type !== "navigation") continue;
+    const el = action.element;
+    if (!el || el.tag !== "a" || !el.text) continue;
+    const href = el.href || action.url;
+    if (!href || seen.has(href)) continue;
+    seen.add(href);
+    links.push({
+      text: el.text.substring(0, 40),
+      href,
+      selector: el.selector || ""
+    });
+  }
+  return links;
+}
+function extractApiEndpoints(network, existingEndpoints) {
+  const endpoints = {};
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (existingEndpoints) {
+    for (const [key, ep] of Object.entries(existingEndpoints)) {
+      endpoints[key] = ep;
+    }
+  }
+  for (const entry of network) {
+    if (!entry.url.includes("/api/") && !entry.url.includes("/v1/") && !entry.url.includes("/v2/") && entry.contentType && !entry.contentType.includes("json") && !entry.contentType.includes("text/")) continue;
+    if (["image", "stylesheet", "font", "manifest"].includes(entry.resourceType)) continue;
+    let path;
+    try {
+      path = new URL(entry.url).pathname;
+    } catch {
+      continue;
+    }
+    const method = entry.method;
+    const key = `${method} ${path}`;
+    if (endpoints[key]) {
+      endpoints[key].timesSeen++;
+      endpoints[key].lastSeen = now;
+    } else {
+      let params = [];
+      if (entry.requestBody && typeof entry.requestBody === "object") {
+        params = Object.keys(entry.requestBody).slice(0, 10);
+      }
+      let responseFields = [];
+      if (entry.responseBody && typeof entry.responseBody === "object") {
+        const resp = entry.responseBody;
+        responseFields = Object.keys(resp).slice(0, 10);
+        if (resp.data && typeof resp.data === "object") {
+          const dataKeys = Object.keys(resp.data).slice(0, 10);
+          responseFields = [...responseFields, ...dataKeys.map((k) => `data.${k}`)];
+        }
+      }
+      endpoints[key] = {
+        method,
+        url: entry.url.substring(0, 200),
+        path,
+        params,
+        responseFields,
+        lastSeen: now,
+        timesSeen: 1
+      };
+    }
+  }
+  return endpoints;
+}
+function mergePages(existing, newPages) {
+  const merged = { ...existing };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (const [path, newPage] of Object.entries(newPages)) {
+    if (merged[path]) {
+      const old = merged[path];
+      const selectorMap = /* @__PURE__ */ new Map();
+      for (const sel of old.selectors) selectorMap.set(sel.selector, sel);
+      for (const sel of newPage.selectors) {
+        const existing2 = selectorMap.get(sel.selector);
+        if (existing2) {
+          existing2.timesSeen += sel.timesSeen;
+          existing2.lastSeen = now;
+          existing2.status = "active";
+        } else {
+          selectorMap.set(sel.selector, sel);
+        }
+      }
+      const newSelectorSet = new Set(newPage.selectors.map((s) => s.selector));
+      for (const sel of selectorMap.values()) {
+        if (!newSelectorSet.has(sel.selector) && sel.timesSeen > 0) {
+        }
+      }
+      merged[path] = {
+        ...newPage,
+        selectors: Array.from(selectorMap.values()).sort((a, b) => b.timesSeen - a.timesSeen),
+        forms: newPage.forms.length > 0 ? newPage.forms : old.forms,
+        navigationLinks: [.../* @__PURE__ */ new Set([...old.navigationLinks, ...newPage.navigationLinks])].slice(0, 50),
+        lastVisited: now
+      };
+    } else {
+      merged[path] = newPage;
+    }
+  }
+  return merged;
+}
+function updateSiteKnowledge(data) {
+  const domain = extractDomain(data.startUrl);
+  const jsonPath = getKnowledgePath(domain, "json");
+  let existing = null;
+  if (existsSync(jsonPath)) {
+    try {
+      existing = JSON.parse(readFileSync(jsonPath, "utf-8"));
+    } catch {
+      existing = null;
+    }
+  }
+  const pageMap = /* @__PURE__ */ new Map();
+  for (const action of data.actions) {
+    const path = normalizePath(action.url);
+    if (!pageMap.has(path)) pageMap.set(path, []);
+    pageMap.get(path).push(action);
+  }
+  const newPages = {};
+  for (const [path, actions] of pageMap) {
+    const fullUrl = actions[0]?.url || data.startUrl;
+    newPages[path] = {
+      url: fullUrl,
+      title: actions[0]?.pageTitle || "",
+      selectors: extractSelectors(data.actions, fullUrl),
+      forms: extractForms(data.actions, fullUrl),
+      navigationLinks: extractNavLinks(actions),
+      lastVisited: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const apiEndpoints = extractApiEndpoints(data.network, existing?.apiEndpoints);
+  const pages = existing ? mergePages(existing.pages, newPages) : newPages;
+  const knowledge = {
+    domain,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+    recordingCount: (existing?.recordingCount || 0) + 1,
+    pages,
+    apiEndpoints,
+    knownIssues: existing?.knownIssues || [],
+    generatedBy: "xbrowser-recorder"
+  };
+  mkdirSync(getKnowledgeDir(), { recursive: true });
+  writeFileSync(jsonPath, JSON.stringify(knowledge, null, 2), "utf-8");
+  writeFileSync(getKnowledgePath(domain, "md"), toMarkdown(knowledge), "utf-8");
+  return knowledge;
+}
+function toMarkdown(kb) {
+  const lines = [];
+  lines.push(`# Site Knowledge: ${kb.domain}`);
+  lines.push("");
+  lines.push("> **Auto-generated by xbrowser recorder. This document is for LLM consumption.**");
+  lines.push("> Use these selectors when writing automation scripts for this site.");
+  lines.push(`> Updated: ${kb.lastUpdated} | Recordings: ${kb.recordingCount}`);
+  lines.push("");
+  lines.push("## Pages");
+  lines.push("");
+  for (const page of Object.values(kb.pages)) {
+    lines.push(`### ${page.url}`);
+    lines.push(`- **Path**: ${normalizePath(page.url)}`);
+    if (page.title) lines.push(`- **Title**: ${page.title}`);
+    lines.push(`- **Last Visited**: ${page.lastVisited}`);
+    lines.push("");
+    if (page.selectors.length > 0) {
+      lines.push("#### Selectors");
+      lines.push("");
+      lines.push("| Selector | Tag | Action | Description | Confidence | Seen |");
+      lines.push("|----------|-----|--------|-------------|------------|------|");
+      for (const sel of page.selectors) {
+        const status = sel.status === "deprecated" ? " \u26A0\uFE0FDEPRECATED" : "";
+        lines.push(
+          `| \`${sel.selector}\` | ${sel.tag} | ${sel.actionType} | ${sel.description} | ${sel.confidence} | ${sel.timesSeen}x${status} |`
+        );
+      }
+      lines.push("");
+    }
+    if (page.forms.length > 0) {
+      lines.push("#### Forms");
+      lines.push("");
+      for (const form of page.forms) {
+        lines.push(`- **${form.name}** (${form.action})`);
+        for (const field of form.fields) {
+          const parts = [field.tag, field.inputType];
+          if (field.placeholder) parts.push(`placeholder="${field.placeholder}"`);
+          lines.push(`  - \`${field.selector}\` \u2192 ${field.label} (${parts.join(", ")})`);
+        }
+        if (form.submitSelector) {
+          lines.push(`  - Submit: \`${form.submitSelector}\``);
+        }
+      }
+      lines.push("");
+    }
+    if (page.navigationLinks.length > 0) {
+      lines.push("#### Navigation Links");
+      lines.push("");
+      for (const link of page.navigationLinks.slice(0, 20)) {
+        lines.push(`- [${link.text}](${link.href}) \u2192 \`${link.selector}\``);
+      }
+      lines.push("");
+    }
+  }
+  const endpoints = Object.values(kb.apiEndpoints);
+  if (endpoints.length > 0) {
+    lines.push("## API Endpoints");
+    lines.push("");
+    lines.push("| Method | Path | Params | Response Fields | Frequency |");
+    lines.push("|--------|------|--------|-----------------|-----------|");
+    for (const ep of endpoints.sort((a, b) => b.timesSeen - a.timesSeen)) {
+      const params = ep.params.length > 0 ? ep.params.join(", ") : "-";
+      const respFields = ep.responseFields.length > 0 ? ep.responseFields.slice(0, 5).join(", ") : "-";
+      lines.push(`| ${ep.method} | ${ep.path} | ${params} | ${respFields} | ${ep.timesSeen}x |`);
+    }
+    lines.push("");
+  }
+  if (kb.knownIssues.length > 0) {
+    lines.push("## Known Issues");
+    lines.push("");
+    for (const issue of kb.knownIssues) {
+      lines.push(`- ${issue}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("## How to Use This Document");
+  lines.push("");
+  lines.push("When writing automation scripts for this site:");
+  lines.push("1. Use the selectors from the **Selectors** tables above");
+  lines.push("2. Prefer selectors with **high confidence** and **higher Seen count**");
+  lines.push("3. For form filling, follow the **Forms** structure");
+  lines.push("4. For API interactions, reference the **API Endpoints** table");
+  lines.push("5. If a selector fails, it may be **deprecated** \u2014 check for alternative selectors");
+  lines.push("");
+  return lines.join("\n");
+}
+function readSiteKnowledge(domain) {
+  const path = getKnowledgePath(domain, "json");
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function readSiteKnowledgeMarkdown(domain) {
+  const path = getKnowledgePath(domain, "md");
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function listSiteKnowledge() {
+  const dir = getKnowledgeDir();
+  if (!existsSync(dir)) return [];
+  try {
+    const files = __require("fs").readdirSync(dir);
+    return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+  } catch {
+    return [];
+  }
+}
+function addKnownIssue(domain, issue) {
+  const kb = readSiteKnowledge(domain);
+  if (!kb) return;
+  const dated = `[${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}] ${issue}`;
+  kb.knownIssues.push(dated);
+  kb.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync(getKnowledgePath(domain, "json"), JSON.stringify(kb, null, 2), "utf-8");
+  writeFileSync(getKnowledgePath(domain, "md"), toMarkdown(kb), "utf-8");
+}
+var init_site_knowledge = __esm({
+  "src/recorder/site-knowledge.ts"() {
+    "use strict";
+  }
+});
+
+// src/recorder/session-recorder.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync2, rmSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/recorder/selector-utils.ts
+function getSelectorGeneratorScript() {
+  return `
+(function() {
+  if (window.__xb_generateSelector) return;
+
+  var IGNORE_CLASS = [
+    /^css-[a-zA-Z0-9]+$/,
+    /^sc-[a-zA-Z0-9]+$/,
+    /^emotion-\\d+$/,
+    /^_[a-f0-9]{4,}$/,
+    /^[a-f0-9]{6,}$/,
+    /^styled-[a-zA-Z0-9]+/,
+    /^__[a-zA-Z0-9]{4,}$/,
+    /^makeStyles-/,
+    /^MuiPrivate/,
+    /^jss\\d+$/,
+    /^ant-[a-z]+$/,
+    /^semi-[a-z]{4,}/
+  ];
+  var STABLE_ATTRS = ['data-testid', 'data-test-id', 'data-cy', 'data-qa', 'data-el'];
+  var MAX_DEPTH = 5;
+
+  function isStableClass(cls) {
+    if (!cls || cls.length <= 1) return false;
+    for (var i = 0; i < IGNORE_CLASS.length; i++) {
+      if (IGNORE_CLASS[i].test(cls)) return false;
+    }
+    return true;
+  }
+
+  function isUnique(root, sel) {
+    try { return root.querySelectorAll(sel).length === 1; } catch(e) { return false; }
+  }
+
+  function esc(s) { return CSS.escape(s); }
+
+  window.__xb_generateSelector = function(el, root) {
+    root = root || document;
+    if (!el || !el.tagName) return null;
+    if (el === root || el === document.documentElement) return { selector: 'html', strategy: 'root', confidence: 'high' };
+
+    var tag = el.tagName.toLowerCase();
+
+    // #id
+    if (el.id) {
+      var s = '#' + esc(el.id);
+      if (isUnique(root, s)) return { selector: s, strategy: 'id', confidence: 'high' };
+      s = tag + s;
+      if (isUnique(root, s)) return { selector: s, strategy: 'id+tag', confidence: 'high' };
+    }
+
+    // [data-testid]
+    for (var si = 0; si < STABLE_ATTRS.length; si++) {
+      var v = el.getAttribute(STABLE_ATTRS[si]);
+      if (v) {
+        var s = '[' + STABLE_ATTRS[si] + '="' + esc(v) + '"]';
+        if (isUnique(root, s)) return { selector: s, strategy: 'testid', confidence: 'high' };
+        s = tag + s;
+        if (isUnique(root, s)) return { selector: s, strategy: 'testid+tag', confidence: 'high' };
+      }
+    }
+
+    // [name]
+    var name = el.getAttribute('name');
+    if (name) {
+      var s = tag + '[name="' + esc(name) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'name', confidence: 'high' };
+    }
+
+    // [aria-label]
+    var aria = el.getAttribute('aria-label');
+    if (aria) {
+      var s = '[aria-label="' + esc(aria.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'aria-label', confidence: 'high' };
+      s = tag + s;
+      if (isUnique(root, s)) return { selector: s, strategy: 'aria-label+tag', confidence: 'high' };
+    }
+
+    // [placeholder]
+    var ph = el.getAttribute('placeholder');
+    if (ph) {
+      var s = tag + '[placeholder="' + esc(ph.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'placeholder', confidence: 'high' };
+    }
+
+    // [alt]
+    var alt = el.getAttribute('alt');
+    if (alt && tag === 'img') {
+      var s = 'img[alt="' + esc(alt.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'alt', confidence: 'high' };
+    }
+
+    // [title]
+    var title = el.getAttribute('title');
+    if (title) {
+      var s = tag + '[title="' + esc(title.substring(0, 60)) + '"]';
+      if (isUnique(root, s)) return { selector: s, strategy: 'title', confidence: 'high' };
+    }
+
+    // Unique attribute (skip URL-like, long)
+    var skipAttr = {class:1,style:1,id:1,name:1,'aria-label':1,placeholder:1,alt:1,title:1,role:1,src:1,href:1,action:1,'data-src':1,'data-href':1};
+    for (var ai = 0; ai < el.attributes.length; ai++) {
+      var a = el.attributes[ai];
+      if (skipAttr[a.name] || a.name.startsWith('data-') || a.name.startsWith('aria-')) continue;
+      if (a.value && a.value.length > 2 && a.value.length <= 60) {
+        var s = tag + '[' + a.name + '="' + esc(a.value) + '"]';
+        if (isUnique(root, s)) return { selector: s, strategy: 'attribute', confidence: 'medium' };
+      }
+    }
+
+    // Class combos
+    var rawCls = (typeof el.className === 'string' ? el.className : '').trim().split(/\\s+/);
+    var cls = rawCls.filter(isStableClass);
+    if (cls.length > 0) {
+      cls.sort(function(a, b) {
+        return root.querySelectorAll('.' + esc(a)).length - root.querySelectorAll('.' + esc(b)).length;
+      });
+      // single class
+      for (var i = 0; i < cls.length; i++) {
+        var s = '.' + esc(cls[i]);
+        if (isUnique(root, s)) return { selector: s, strategy: 'class', confidence: 'medium' };
+      }
+      // tag + class
+      for (var i = 0; i < cls.length; i++) {
+        var s = tag + '.' + esc(cls[i]);
+        if (isUnique(root, s)) return { selector: s, strategy: 'tag+class', confidence: 'medium' };
+      }
+      // 2-class combo
+      for (var i = 0; i < cls.length && i < 5; i++) {
+        for (var j = i+1; j < cls.length && j < 5; j++) {
+          var s = '.' + esc(cls[i]) + '.' + esc(cls[j]);
+          if (isUnique(root, s)) return { selector: s, strategy: 'class-combo', confidence: 'medium' };
+        }
+      }
+      // tag + 2-class combo
+      for (var i = 0; i < cls.length && i < 4; i++) {
+        for (var j = i+1; j < cls.length && j < 4; j++) {
+          var s = tag + '.' + esc(cls[i]) + '.' + esc(cls[j]);
+          if (isUnique(root, s)) return { selector: s, strategy: 'tag+class-combo', confidence: 'medium' };
+        }
+      }
+    }
+
+    // Parent scope
+    var parent = el.parentElement;
+    if (parent && parent !== root) {
+      if (parent.id) {
+        var s = '#' + esc(parent.id) + ' > ' + tag;
+        if (isUnique(root, s)) return { selector: s, strategy: 'parent-scope', confidence: 'medium' };
+      }
+      var pCls = (typeof parent.className === 'string' ? parent.className : '').trim().split(/\\s+/).filter(isStableClass);
+      for (var i = 0; i < pCls.length; i++) {
+        var s = '.' + esc(pCls[i]) + ' > ' + tag;
+        if (isUnique(root, s)) return { selector: s, strategy: 'parent-class-scope', confidence: 'medium' };
+      }
+      if (cls.length > 0) {
+        for (var i = 0; i < Math.min(cls.length, 3); i++) {
+          var s = parent.tagName.toLowerCase() + ' > ' + tag + '.' + esc(cls[i]);
+          if (isUnique(root, s)) return { selector: s, strategy: 'parent>tag.class', confidence: 'medium' };
+        }
+      }
+    }
+
+    // :nth-of-type chain \u2014 walk all the way up, then find shortest unique suffix
+    var path = [];
+    var cur = el;
+    while (cur && cur !== root && cur !== document.documentElement) {
+      var p = cur.parentElement;
+      if (!p || p === root) break;
+      var t = cur.tagName.toLowerCase();
+      var same = [];
+      for (var k = 0; k < p.children.length; k++) {
+        if (p.children[k].tagName === cur.tagName) same.push(p.children[k]);
+      }
+      var nth = same.length === 1 ? null : (same.indexOf(cur) + 1);
+      path.unshift({tag: t, nth: nth});
+      if (cur !== el && cur.id) {
+        path.unshift({tag: '#' + esc(cur.id), nth: null});
+        break;
+      }
+      cur = p;
+    }
+    // Try suffixes from shortest to longest
+    for (var d = 1; d <= path.length; d++) {
+      var parts = path.slice(-d).map(function(p) {
+        return p.nth !== null ? p.tag + ':nth-of-type(' + p.nth + ')' : p.tag;
+      });
+      var sel = parts.join(' > ');
+      if (isUnique(root, sel)) return { selector: sel, strategy: 'nth-of-type', confidence: 'low' };
+    }
+    // Fallback
+    if (path.length > 0) {
+      var parts = path.map(function(p) {
+        return p.nth !== null ? p.tag + ':nth-of-type(' + p.nth + ')' : p.tag;
+      });
+      return { selector: parts.join(' > '), strategy: 'nth-of-type', confidence: 'low' };
+    }
+    return { selector: tag, strategy: 'tag-only', confidence: 'low' };
+  };
+})();
+`;
+}
+
+// src/recorder/session-recorder.ts
+init_site_knowledge();
+var ACTION_SIGNAL_SCRIPT = `
+(function() {
+  if (window.__xb_action_signal) return;
+  window.__xb_action_signal = true;
+  window.__xb_pending_actions = [];
+
+  // --- Unique short selector generator (delegates to 13-strategy selector-utils) ---
+  function uniqueSelector(el) {
+    if (!el || !el.tagName) return null;
+    var doc = el.ownerDocument || document;
+
+    function isUnique(sel) {
+      try { return doc.querySelectorAll(sel).length === 1; } catch(e) { return false; }
+    }
+
+    // Prefer window.__xb_generateSelector from selector-utils (13 strategies)
+    if (typeof window.__xb_generateSelector === 'function') {
+      try {
+        var result = window.__xb_generateSelector(el, doc);
+        if (result && result.selector) return result.selector;
+      } catch(e) { /* fallback to local logic */ }
+    }
+
+    // 1. #id (shortest, globally unique)
+    if (el.id) {
+      var idSel = '#' + CSS.escape(el.id);
+      if (isUnique(idSel)) return idSel;
+    }
+
+    // 2. [data-testid="..."]
+    var testId = el.getAttribute('data-testid') || el.getAttribute('data-test-id');
+    if (testId) {
+      var sel = '[data-testid="' + testId + '"]';
+      if (isUnique(sel)) return sel;
+    }
+
+    // 3. [name="..."]
+    var name = el.getAttribute('name');
+    if (name) {
+      var sel = el.tagName.toLowerCase() + '[name="' + name + '"]';
+      if (isUnique(sel)) return sel;
+    }
+
+    // 4. [aria-label="..."]
+    var aria = el.getAttribute('aria-label');
+    if (aria) {
+      var sel = '[aria-label="' + aria.substring(0, 50) + '"]';
+      if (isUnique(sel)) return sel;
+    }
+
+    // 5. [placeholder="..."]
+    var ph = el.getAttribute('placeholder');
+    if (ph) {
+      var sel = el.tagName.toLowerCase() + '[placeholder="' + ph.substring(0, 50) + '"]';
+      if (isUnique(sel)) return sel;
+    }
+
+    // 6. tag.class \u2014 pick shortest combo that's unique
+    var tag = el.tagName.toLowerCase();
+    if (typeof el.className === 'string' && el.className.trim()) {
+      var classes = el.className.trim().split(/\\s+/).filter(function(c) {
+        return c && !/^(ng-|_|css-|sc-|styled-|emotion-)/.test(c);
+      });
+      // Sort by rarity (less common class first)
+      classes.sort(function(a, b) {
+        return doc.querySelectorAll('.' + a).length - doc.querySelectorAll('.' + b).length;
+      });
+      // Try tag + single class
+      for (var i = 0; i < classes.length; i++) {
+        var sel = tag + '.' + CSS.escape(classes[i]);
+        if (isUnique(sel)) return sel;
+      }
+      // Try tag + two classes
+      if (classes.length >= 2) {
+        var sel = tag + '.' + CSS.escape(classes[0]) + '.' + CSS.escape(classes[1]);
+        if (isUnique(sel)) return sel;
+      }
+    }
+
+    // 7. parent > tag  (one level up)
+    var parent = el.parentElement;
+    if (parent) {
+      var parentSel = parent.id ? '#' + CSS.escape(parent.id) : parent.tagName.toLowerCase();
+      var sel = parentSel + ' > ' + tag;
+      if (isUnique(sel)) return sel;
+    }
+
+    // 8. :nth-child fallback (tag:nth-child(n) under parent)
+    if (parent) {
+      var siblings = Array.from(parent.children);
+      var idx = siblings.indexOf(el) + 1;
+      var parentSel = parent.id ? '#' + CSS.escape(parent.id) : parent.tagName.toLowerCase();
+      var sel = parentSel + ' > ' + tag + ':nth-child(' + idx + ')';
+      if (isUnique(sel)) return sel;
+    }
+
+    // 9. Last resort: full tag
+    return tag;
+  }
+
+  // --- Element descriptor ---
+  function describe(el) {
+    if (!el || !el.tagName) return null;
+    var tag = el.tagName.toLowerCase();
+    var isInputLike = (tag === 'input' || tag === 'textarea' || tag === 'select');
+    var displayText = isInputLike
+      ? (el.value || el.getAttribute('placeholder') || '').trim().substring(0, 40)
+      : (el.textContent || '').trim().substring(0, 40);
+    if (tag === 'a' && el.getAttribute('href')) displayText = el.textContent.trim().substring(0, 40);
+
+    // Prefer window.__xb_generateSelector (13 strategies) \u2014 also extracts strategy + confidence
+    var selector, strategy, confidence;
+    if (typeof window.__xb_generateSelector === 'function') {
+      try {
+        var result = window.__xb_generateSelector(el, el.ownerDocument || document);
+        if (result && result.selector) {
+          selector = result.selector;
+          strategy = result.strategy;
+          confidence = result.confidence;
+        }
+      } catch(e) { /* fall through to local */ }
+    }
+    if (!selector) {
+      selector = uniqueSelector(el);
+    }
+
+    // For low-confidence selectors (nth-of-type), generate a text-based fallback
+    // when the element has short, unique text (e.g. menu items "\u5220\u9664", "\u786E\u8BA4")
+    var textFallback;
+    var popupContext;
+
+    // Check if element is inside a popup/menu first (needed for scoped text uniqueness)
+    var popupEl;
+    try {
+      popupEl = el.closest('[role="menu"], [role="listbox"], [role="dialog"], [role="tooltip"], [role="list"], [class*="popover"], [class*="popup"], [class*="dropdown"], [class*="menu"], [class*="modal"], [id*="menu"], [id*="dropdown"], [id*="popup"], [id*="modal"]');
+    } catch(e) {}
+
+    if (confidence === 'low') {
+      var rawText = (el.textContent || '').trim();
+      if (rawText && rawText.length >= 1 && rawText.length <= 30 && el.children.length === 0) {
+        try {
+          var doc = el.ownerDocument || document;
+          var escapedText = rawText.replace(/'/g, "\\'");
+
+          // If inside popup, check uniqueness WITHIN popup only
+          var count;
+          if (popupEl && popupEl !== el) {
+            var popupCount = doc.evaluate(
+              "count(.//*[normalize-space(text())='" + escapedText + "'])",
+              popupEl, null, XPathResult.NUMBER_TYPE, null
+            );
+            count = popupCount.numberValue;
+          } else {
+            // Check global uniqueness
+            var globalCount = doc.evaluate(
+              "count(//*[normalize-space(text())='" + escapedText + "'])",
+              doc, null, XPathResult.NUMBER_TYPE, null
+            );
+            count = globalCount.numberValue;
+          }
+
+          if (count === 1) {
+            textFallback = {
+              type: popupEl && popupEl !== el ? 'popup-text' : 'text',
+              value: rawText,
+              selector: popupEl && popupEl !== el ? 'popup-text=' + rawText : 'text=' + rawText,
+            };
+          }
+        } catch(e) { /* xpath not available or error */ }
+      }
+    }
+
+    // Generate popup context info
+    if (popupEl && popupEl !== el) {
+      try {
+        var popupResult = window.__xb_generateSelector
+          ? window.__xb_generateSelector(popupEl, el.ownerDocument || document)
+          : null;
+        if (popupResult && popupResult.selector) {
+          popupContext = {
+            containerSelector: popupResult.selector,
+            containerText: (popupEl.textContent || '').trim().substring(0, 50),
+          };
+        }
+      } catch(e) { /* skip */ }
+    }
+
+    return {
+      tag: tag,
+      selector: selector,
+      text: displayText,
+      strategy: strategy,
+      confidence: confidence,
+      textFallback: textFallback,
+      popup: popupContext,
+      role: el.getAttribute('role') || undefined,
+      type: el.getAttribute('type') || undefined,
+      placeholder: el.getAttribute('placeholder') || undefined,
+      ariaLabel: el.getAttribute('aria-label') || undefined,
+      href: el.getAttribute('href') ? el.getAttribute('href').substring(0, 80) : undefined,
+    };
+  }
+
+  // \u2500\u2500 Mouse trajectory capture \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+  // Continuously samples mousemove (every ~60ms).
+  // When a meaningful action fires, we snapshot the buffer,
+  // simplify it (Douglas-Peucker), and attach as trajectory.
+  var __xb_traj_buffer = [];        // raw samples: {x, y, t}
+  var __xb_traj_last_action = null; // {x, y, t} of previous action
+
+  document.addEventListener('mousemove', function(e) {
+    var now = Date.now();
+    // Sample at ~60ms intervals
+    if (__xb_traj_buffer.length > 0) {
+      var last = __xb_traj_buffer[__xb_traj_buffer.length - 1];
+      if (now - last.t < 60) return;
+    }
+    __xb_traj_buffer.push({ x: e.clientX, y: e.clientY, t: now });
+    // Cap buffer at 200 points (~12 seconds at 60ms)
+    if (__xb_traj_buffer.length > 200) {
+      __xb_traj_buffer = __xb_traj_buffer.slice(-150);
+    }
+  }, true);
+
+  // Douglas-Peucker simplification: keep only points that define the path shape
+  function dpSimplify(pts, epsilon) {
+    if (pts.length <= 2) return pts;
+    var maxDist = 0, maxIdx = 0;
+    var first = pts[0], last = pts[pts.length - 1];
+    for (var i = 1; i < pts.length - 1; i++) {
+      var d = pointLineDistance(pts[i], first, last);
+      if (d > maxDist) { maxDist = d; maxIdx = i; }
+    }
+    if (maxDist > epsilon) {
+      var left = dpSimplify(pts.slice(0, maxIdx + 1), epsilon);
+      var right = dpSimplify(pts.slice(maxIdx), epsilon);
+      return left.slice(0, -1).concat(right);
+    }
+    return [first, last];
+  }
+
+  function pointLineDistance(p, a, b) {
+    var dx = b.x - a.x, dy = b.y - a.y;
+    var lenSq = dx * dx + dy * dy;
+    if (lenSq === 0) return Math.sqrt((p.x - a.x) * (p.x - a.x) + (p.y - a.y) * (p.y - a.y));
+    var t = Math.max(0, Math.min(1, ((p.x - a.x) * dx + (p.y - a.y) * dy) / lenSq));
+    var projX = a.x + t * dx, projY = a.y + t * dy;
+    return Math.sqrt((p.x - projX) * (p.x - projX) + (p.y - projY) * (p.y - projY));
+  }
+
+  // Extract trajectory from buffer ending at (toX, toY, toT).
+  // Returns null if no meaningful path.
+  function extractTrajectory(toX, toY) {
+    var now = Date.now();
+    // Add current position as final point
+    var raw = __xb_traj_buffer.slice();
+    raw.push({ x: toX, y: toY, t: now });
+
+    // Trim to last 5 seconds
+    var cutoff = now - 5000;
+    while (raw.length > 0 && raw[0].t < cutoff) raw.shift();
+    if (raw.length < 2) { __xb_traj_buffer = []; return null; }
+
+    // If we know the previous action position, prepend it as start
+    if (__xb_traj_last_action) {
+      // Trim raw points before the last action
+      while (raw.length > 1 && raw[0].t < __xb_traj_last_action.t) raw.shift();
+      raw.unshift({ x: __xb_traj_last_action.x, y: __xb_traj_last_action.y, t: __xb_traj_last_action.t });
+    }
+
+    // Simplify (epsilon=3px keeps shape but removes jitter)
+    var simplified = dpSimplify(raw, 3);
+    if (simplified.length < 2) { __xb_traj_buffer = []; return null; }
+
+    // Build result with delta times
+    var totalDist = 0;
+    var points = [];
+    for (var i = 0; i < simplified.length; i++) {
+      var dt = i === 0 ? 0 : simplified[i].t - simplified[i - 1].t;
+      if (i > 0) {
+        var ddx = simplified[i].x - simplified[i - 1].x;
+        var ddy = simplified[i].y - simplified[i - 1].y;
+        totalDist += Math.sqrt(ddx * ddx + ddy * ddy);
+      }
+      points.push({ x: simplified[i].x, y: simplified[i].y, dt: dt });
+    }
+
+    var duration = simplified[simplified.length - 1].t - simplified[0].t;
+
+    // Only return if meaningful movement (>5px total distance)
+    if (totalDist < 5) { __xb_traj_buffer = []; return null; }
+
+    // Reset buffer
+    __xb_traj_buffer = [];
+    __xb_traj_last_action = { x: toX, y: toY, t: now };
+
+    return { points: points, distance: Math.round(totalDist), duration: duration };
+  }
+
+  // \u2500\u2500 End trajectory capture \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+
+  // Expose describe() for CDP command element metadata extraction
+  window.__xb_describe = describe;
+
+  function isMeaningful(el) {
+    if (!el || !el.tagName) return false;
+    var tag = el.tagName.toLowerCase();
+    if (tag === 'a' || tag === 'button' || tag === 'input' || tag === 'textarea' || tag === 'select') return true;
+    if (el.getAttribute('role')) return true;
+    if (el.getAttribute('aria-label')) return true;
+    var text = (el.textContent || '').trim();
+    if (text.length > 0 && text.length <= 80) return true;
+    return false;
+  }
+
+  function resolveMeaningful(e) {
+    var path = e.composedPath ? e.composedPath() : [e.target];
+    for (var i = 0; i < Math.min(path.length, 8); i++) {
+      var el = path[i];
+      if (isMeaningful(el)) return el;
+    }
+    return path[0] || e.target;
+  }
+
+  function actualTarget(e) {
+    var path = e.composedPath && e.composedPath();
+    return (path && path.length > 0) ? path[0] : e.target;
+  }
+
+  // --- Input debounce: coalesce rapid keystrokes on same element ---
+  var __xb_input_timer = null;
+  var __xb_input_pending = null;
+
+  function flushInputAction() {
+    if (__xb_input_pending) {
+      window.__xb_pending_actions.push(__xb_input_pending);
+      __xb_input_pending = null;
+    }
+    __xb_input_timer = null;
+  }
+
+  function pushAction(type, detail) {
+    // Attach mouse trajectory for actions with coordinates
+    if (detail && detail.x != null && detail.y != null) {
+      var traj = extractTrajectory(detail.x, detail.y);
+      if (traj) detail.trajectory = traj;
+    }
+
+    if (type === 'input') {
+      if (__xb_input_timer) clearTimeout(__xb_input_timer);
+      __xb_input_pending = {
+        type: type,
+        ts: Date.now(),
+        url: location.href,
+        title: document.title,
+        ...detail,
+      };
+      __xb_input_timer = setTimeout(flushInputAction, 800);
+      return;
+    }
+    if (type === 'click' || type === 'submit' || type === 'keydown') {
+      if (__xb_input_timer) { clearTimeout(__xb_input_timer); flushInputAction(); }
+    }
+    window.__xb_pending_actions.push({
+      type: type,
+      ts: Date.now(),
+      url: location.href,
+      title: document.title,
+      ...detail,
+    });
+  }
+
+  // --- Click context: capture popover/dropdown/menu/state changes after click ---
+  var POPOVER_SELECTORS = [
+    '[role="menu"]','[role="listbox"]','[role="dialog"]','[role="tooltip"]','[role="popover"]',
+    '[role="combobox"]','[role="tree"]','[role="grid"]',
+    '.popover','.popup','.dropdown','.menu','.modal','.tooltip','.panel',
+    '[class*="popover"]','[class*="popup"]','[class*="dropdown"]','[class*="menu"]','[class*="tooltip"]',
+    '[class*="modal"]','[class*="panel"]','[class*="overlay"]','[class*="sheet"]',
+    '[data-popup]','[data-dropdown]','[data-menu]','[data-popover]',
+    '.semi-dropdown','.semi-popover','.semi-modal','.semi-select-option',
+    '.ant-dropdown','.ant-popover','.ant-modal','.ant-select-dropdown',
+    '.el-dropdown','.el-popover','.el-dialog','.el-select-dropdown',
+    '.t-dropdown','.t-popup','.t-dialog'
+  ];
+
+  function isNearClick(el, cx, cy, range) {
+    try {
+      var r = el.getBoundingClientRect();
+      if (!r || r.width === 0 || r.height === 0) return false;
+      // Element overlaps with or is near the click area
+      var margin = range || 300;
+      return !(r.left > cx + margin || r.right < cx - margin || r.top > cy + margin || r.bottom < cy - margin);
+    } catch(e) { return false; }
+  }
+
+  function captureVisibleContext(cx, cy) {
+    var result = { appeared: [], disappeared: [], stateChanges: [] };
+    try {
+      // 1. Find popover/dropdown/menu elements near the click
+      for (var i = 0; i < POPOVER_SELECTORS.length; i++) {
+        try {
+          var els = document.querySelectorAll(POPOVER_SELECTORS[i]);
+          for (var j = 0; j < els.length; j++) {
+            var el = els[j];
+            if (!isNearClick(el, cx, cy, 500)) continue;
+            var rect = el.getBoundingClientRect();
+            if (rect.width === 0 || rect.height === 0) continue;
+            var items = [];
+            // Capture child items (up to 20)
+            var children = el.querySelectorAll('a,button,[role="menuitem"],[role="option"],[role="treeitem"],li,div[class*="item"]');
+            for (var k = 0; k < Math.min(children.length, 20); k++) {
+              var child = children[k];
+              var childText = (child.textContent || '').trim().substring(0, 60);
+              if (!childText) continue;
+              var childInfo = { text: childText };
+              if (child.disabled) childInfo.disabled = true;
+              if (child.getAttribute('aria-disabled') === 'true') childInfo.disabled = true;
+              if (child.tagName) childInfo.tag = child.tagName.toLowerCase();
+              if (child.href) childInfo.href = child.href.substring(0, 80);
+              items.push(childInfo);
+            }
+            result.appeared.push({
+              tag: el.tagName.toLowerCase(),
+              selector: uniqueSelector(el),
+              role: el.getAttribute('role'),
+              text: (el.textContent || '').trim().substring(0, 100),
+              rect: { x: Math.round(rect.x), y: Math.round(rect.y), w: Math.round(rect.width), h: Math.round(rect.height) },
+              items: items,
+            });
+          }
+        } catch(e) {}
+      }
+
+      // 2. Find elements that changed aria-expanded or disabled state near click
+      var nearbyEls = document.elementsFromPoint ? document.elementsFromPoint(cx, cy) : [];
+      // Also check elements in a wider area
+      var area = document.querySelector('body');
+      if (area) {
+        var allInteractive = area.querySelectorAll('[aria-expanded],[disabled],[aria-disabled],[aria-selected],[data-state]');
+        for (var i = 0; i < allInteractive.length; i++) {
+          var el = allInteractive[i];
+          if (!isNearClick(el, cx, cy, 400)) continue;
+          var info = { tag: el.tagName.toLowerCase(), text: (el.textContent || '').trim().substring(0, 60) };
+          if (el.id) info.id = el.id;
+          if (el.getAttribute('aria-expanded')) info.ariaExpanded = el.getAttribute('aria-expanded');
+          if (el.disabled) info.disabled = true;
+          if (el.getAttribute('aria-disabled') === 'true') info.disabled = true;
+          if (el.getAttribute('aria-selected')) info.ariaSelected = el.getAttribute('aria-selected');
+          if (el.getAttribute('data-state')) info.dataState = el.getAttribute('data-state');
+          result.stateChanges.push(info);
+        }
+      }
+    } catch(e) {}
+    // Deduplicate appeared by selector
+    var seen = {};
+    result.appeared = result.appeared.filter(function(item) {
+      if (!item.selector) return true;
+      if (seen[item.selector]) return false;
+      seen[item.selector] = true;
+      return true;
+    });
+    return result;
+  }
+
+  document.addEventListener('click', function(e) {
+    var cx = e.clientX, cy = e.clientY;
+    // Snapshot before (for diff)
+    var beforeExpanded = {};
+    try {
+      var expandedEls = document.querySelectorAll('[aria-expanded]');
+      for (var i = 0; i < expandedEls.length; i++) {
+        var el = expandedEls[i];
+        if (isNearClick(el, cx, cy, 400)) {
+          beforeExpanded[el.id || uniqueSelector(el)] = el.getAttribute('aria-expanded');
+        }
+      }
+    } catch(e) {}
+
+    pushAction('click', { element: describe(resolveMeaningful(e)), x: cx, y: cy });
+
+    // After 200ms, capture what changed
+    setTimeout(function() {
+      try {
+        var ctx = captureVisibleContext(cx, cy);
+        // Check aria-expanded changes
+        try {
+          var expandedEls = document.querySelectorAll('[aria-expanded]');
+          for (var i = 0; i < expandedEls.length; i++) {
+            var el = expandedEls[i];
+            var key = el.id || uniqueSelector(el);
+            var now = el.getAttribute('aria-expanded');
+            if (beforeExpanded[key] !== undefined && beforeExpanded[key] !== now) {
+              ctx.stateChanges.push({
+                tag: el.tagName.toLowerCase(),
+                text: (el.textContent || '').trim().substring(0, 60),
+                id: el.id || undefined,
+                ariaExpanded: now,
+                changed: true,
+              });
+            }
+          }
+        } catch(e) {}
+        if (ctx.appeared.length > 0 || ctx.stateChanges.length > 0) {
+          var lastAction = window.__xb_pending_actions[window.__xb_pending_actions.length - 1];
+          if (lastAction && lastAction.type === 'click') {
+            lastAction.clickContext = ctx;
+          }
+        }
+      } catch(e) {}
+    }, 200);
+  }, true);
+
+  document.addEventListener('input', function(e) {
+    var target = actualTarget(e);
+    pushAction('input', {
+      element: describe(target),
+      value: (target.value || target.textContent || '').substring(0, 200),
+    });
+  }, true);
+
+  document.addEventListener('change', function(e) {
+    var target = actualTarget(e);
+    var tag = target.tagName && target.tagName.toLowerCase();
+    if (tag === 'select') {
+      pushAction('change', { element: describe(target), value: (target.value || '').substring(0, 100) });
+    } else if (tag === 'input' && target.type === 'file') {
+      var files = target.files;
+      var fileNames = [];
+      for (var i = 0; i < files.length; i++) {
+        fileNames.push(files[i].name);
+      }
+      // Read file contents asynchronously, then push action
+      var readers = [];
+      for (var i = 0; i < files.length; i++) {
+        readers.push(new Promise(function(resolve) {
+          var reader = new FileReader();
+          reader.onload = function() { resolve(reader.result); };
+          reader.onerror = function() { resolve(null); };
+          reader.readAsDataURL(files[i]);
+        }));
+      }
+      Promise.all(readers).then(function(contents) {
+        var fileData = [];
+        for (var i = 0; i < files.length; i++) {
+          fileData.push({
+            name: files[i].name,
+            type: files[i].type,
+            size: files[i].size,
+            dataUrl: contents[i],
+          });
+        }
+        pushAction('filechooser', {
+          element: describe(target),
+          value: fileNames.join(', '),
+          files: {
+            names: fileNames,
+            count: files.length,
+            isMultiple: target.multiple,
+            fileData: fileData,
+          },
+        });
+      });
+    }
+  }, true);
+
+  document.addEventListener('keydown', function(e) {
+    // Special keys always recorded
+    if (e.key === 'Enter' || e.key === 'Tab' || e.key === 'Escape' || e.key.startsWith('Arrow')) {
+      pushAction('keydown', { key: e.key, element: describe(actualTarget(e)) });
+      return;
+    }
+    // Editing keys
+    if (e.key === 'Backspace' || e.key === 'Delete') {
+      pushAction('keydown', { key: e.key, element: describe(actualTarget(e)) });
+      return;
+    }
+    // Modifier combinations (Ctrl/Cmd/Alt + key)
+    if (e.ctrlKey || e.metaKey || e.altKey) {
+      var combo = '';
+      if (e.ctrlKey) combo += 'Ctrl+';
+      if (e.metaKey) combo += 'Meta+';
+      if (e.altKey) combo += 'Alt+';
+      if (e.shiftKey) combo += 'Shift+';
+      combo += e.key;
+      pushAction('keydown', { key: combo, element: describe(actualTarget(e)) });
+    }
+  }, true);
+
+  document.addEventListener('submit', function(e) {
+    pushAction('submit', { element: describe(actualTarget(e)) });
+  }, true);
+
+  document.addEventListener('scroll', function() {
+    if (!window.__xb_last_scroll || Date.now() - window.__xb_last_scroll > 500) {
+      window.__xb_last_scroll = Date.now();
+      pushAction('scroll', { scrollX: window.scrollX, scrollY: window.scrollY });
+    }
+  }, true);
+
+  // \u2500\u2500 Double click \u2500\u2500
+  document.addEventListener('dblclick', function(e) {
+    pushAction('dblclick', {
+      element: describe(resolveMeaningful(e)),
+      x: e.clientX,
+      y: e.clientY,
+    });
+  }, true);
+
+  // \u2500\u2500 Right click (context menu) \u2500\u2500
+  document.addEventListener('contextmenu', function(e) {
+    pushAction('contextmenu', {
+      element: describe(resolveMeaningful(e)),
+      x: e.clientX,
+      y: e.clientY,
+    });
+  }, true);
+
+  // \u2500\u2500 Hover (throttled to 800ms) \u2500\u2500
+  var __xb_last_hover = 0;
+  document.addEventListener('mouseover', function(e) {
+    if (Date.now() - __xb_last_hover < 800) return;
+    __xb_last_hover = Date.now();
+    var target = resolveMeaningful(e);
+    // Only record hover on interactive elements
+    var tag = target.tagName && target.tagName.toLowerCase();
+    var isInteractive = tag === 'a' || tag === 'button' || tag === 'input'
+      || tag === 'select' || tag === 'textarea' || tag === 'summary'
+      || target.getAttribute('role') === 'button'
+      || target.getAttribute('role') === 'link'
+      || target.getAttribute('role') === 'menuitem'
+      || target.getAttribute('role') === 'tab'
+      || target.getAttribute('role') === 'option'
+      || !!target.closest('[role="menu"], [role="menubar"], [role="tablist"], [role="listbox"], [role="tree"], nav, menu');
+    if (isInteractive) {
+      pushAction('hover', {
+        element: describe(target),
+        x: e.clientX,
+        y: e.clientY,
+      });
+    }
+  }, true);
+
+  // \u2500\u2500 Drag & drop \u2500\u2500
+  var __xb_drag_source = null;
+  var __xb_drag_start_pos = null;
+  document.addEventListener('dragstart', function(e) {
+    __xb_drag_source = e.target;
+    __xb_drag_start_pos = { x: e.clientX, y: e.clientY };
+  }, true);
+  document.addEventListener('drop', function(e) {
+    if (__xb_drag_source && __xb_drag_start_pos) {
+      pushAction('drag', {
+        x: e.clientX,
+        y: e.clientY,
+        drag: {
+          fromX: __xb_drag_start_pos.x,
+          fromY: __xb_drag_start_pos.y,
+          toX: e.clientX,
+          toY: e.clientY,
+          source: describe(__xb_drag_source),
+          target: describe(resolveMeaningful(e)),
+        },
+      });
+    }
+    __xb_drag_source = null;
+    __xb_drag_start_pos = null;
+  }, true);
+  document.addEventListener('dragend', function() {
+    __xb_drag_source = null;
+    __xb_drag_start_pos = null;
+  }, true);
+
+  // \u2500\u2500 Window resize \u2500\u2500
+  var __xb_last_resize = 0;
+  window.addEventListener('resize', function() {
+    if (Date.now() - __xb_last_resize < 1000) return;
+    __xb_last_resize = Date.now();
+    pushAction('resize', {
+      resize: { width: window.innerWidth, height: window.innerHeight },
+    });
+  }, true);
+
+  // \u2500\u2500 Clipboard (copy/paste/cut) \u2500\u2500
+  document.addEventListener('copy', function(e) {
+    pushAction('clipboard', { clipboard: { operation: 'copy' } });
+  }, true);
+  document.addEventListener('paste', function(e) {
+    var preview = '';
+    try {
+      preview = (e.clipboardData || window.clipboardData).getData('text').substring(0, 100);
+    } catch(ex) {}
+    pushAction('clipboard', { clipboard: { operation: 'paste', textPreview: preview } });
+  }, true);
+  document.addEventListener('cut', function(e) {
+    pushAction('clipboard', { clipboard: { operation: 'cut' } });
+  }, true);
+
+  // \u2500\u2500 Touch events \u2500\u2500
+  document.addEventListener('touchstart', function(e) {
+    var touches = [];
+    for (var i = 0; i < e.touches.length; i++) {
+      touches.push({ x: e.touches[i].clientX, y: e.touches[i].clientY });
+    }
+    pushAction('touch', {
+      element: describe(resolveMeaningful(e)),
+      touch: { touchType: 'start', touches: touches },
+    });
+  }, true);
+  document.addEventListener('touchend', function(e) {
+    var touches = [];
+    for (var i = 0; i < e.changedTouches.length; i++) {
+      touches.push({ x: e.changedTouches[i].clientX, y: e.changedTouches[i].clientY });
+    }
+    pushAction('touch', {
+      element: describe(resolveMeaningful(e)),
+      touch: { touchType: 'end', touches: touches },
+    });
+  }, true);
+
+  // \u2500\u2500 Focus / Blur \u2500\u2500
+  document.addEventListener('focusin', function(e) {
+    var target = actualTarget(e);
+    var tag = target.tagName && target.tagName.toLowerCase();
+    if (tag === 'input' || tag === 'textarea' || tag === 'select' || target.isContentEditable) {
+      pushAction('focus', {
+        element: describe(target),
+        focus: { focusType: 'focus' },
+      });
+    }
+  }, true);
+  document.addEventListener('focusout', function(e) {
+    var target = actualTarget(e);
+    var tag = target.tagName && target.tagName.toLowerCase();
+    if (tag === 'input' || tag === 'textarea' || tag === 'select' || target.isContentEditable) {
+      pushAction('focus', {
+        element: describe(target),
+        focus: { focusType: 'blur' },
+      });
+    }
+  }, true);
+
+  // \u2500\u2500 Visibility change (tab switch) \u2500\u2500
+  document.addEventListener('visibilitychange', function() {
+    pushAction('visibility', {
+      visibility: { state: document.hidden ? 'hidden' : 'visible' },
+    });
+  }, true);
+})();
+`;
+var CHECKPOINT_OVERLAY_SCRIPT = `
+(function() {
+  if (window.__xb_checkpoint_overlay) return;
+  window.__xb_checkpoint_overlay = true;
+
+  var __xb_overlay = null;       // main overlay container
+  var __xb_highlight = null;     // highlight box around hovered element
+  var __xb_preview = null;       // content preview panel
+  var __xb_hint = null;          // top hint bar
+  var __xb_active = false;       // is marking mode active
+  var __xb_hovered_el = null;    // currently hovered element
+  var __xb_flash_timer = null;
+
+  // \u2500\u2500 helper: get element content for preview \u2500\u2500
+  function getElementContent(el) {
+    var texts = [];
+    // Collect child items (li, option, button, menu items)
+    var children = el.querySelectorAll('li, option, button, [role="option"], [role="menuitem"], [class*="item"], [class*="option"], a[href]');
+    if (children.length > 0) {
+      for (var i = 0; i < Math.min(children.length, 20); i++) {
+        var t = children[i].textContent.trim();
+        if (t && t.length < 100) texts.push(t);
+      }
+    }
+    if (texts.length > 0) return texts;
+    // Fallback: element's own text (truncated)
+    var own = el.textContent.trim();
+    if (own.length > 0) return [own.substring(0, 300)];
+    return [];
+  }
+
+  // \u2500\u2500 helper: get short selector for element \u2500\u2500
+  function shortSelector(el) {
+    if (!el || !el.tagName) return '';
+    if (el.id) return '#' + el.id;
+    if (el.getAttribute('data-testid')) return '[data-testid="' + el.getAttribute('data-testid') + '"]';
+    if (el.getAttribute('aria-label')) return '[aria-label="' + el.getAttribute('aria-label').substring(0, 30) + '"]';
+    if (el.className && typeof el.className === 'string') {
+      var cls = el.className.trim().split(/\\s+/)[0];
+      if (cls) return el.tagName.toLowerCase() + '.' + cls;
+    }
+    return el.tagName.toLowerCase();
+  }
+
+  // \u2500\u2500 helper: tag label \u2500\u2500
+  function tagLabel(el) {
+    var tag = el.tagName.toLowerCase();
+    var type = el.getAttribute('type');
+    var role = el.getAttribute('role');
+    var placeholder = el.getAttribute('placeholder');
+    var text = (el.textContent || '').trim().substring(0, 40);
+    var parts = [tag];
+    if (type) parts.push('type=' + type);
+    if (role) parts.push('role=' + role);
+    if (placeholder) parts.push('"' + placeholder.substring(0, 20) + '"');
+    if (text && parts.length < 3) parts.push('"' + text + '"');
+    return parts.join(' ');
+  }
+
+  // \u2500\u2500 create overlay elements \u2500\u2500
+  function createOverlay() {
+    __xb_overlay = document.createElement('div');
+    __xb_overlay.id = '__xb_mark_overlay';
+    __xb_overlay.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:999999;';
+
+    // Highlight box
+    __xb_highlight = document.createElement('div');
+    __xb_highlight.style.cssText = 'position:fixed;border:3px solid #3b82f6;border-radius:4px;pointer-events:none;transition:all 0.1s ease;display:none;box-shadow:0 0 12px rgba(59,130,246,0.5);';
+    __xb_overlay.appendChild(__xb_highlight);
+
+    // Content preview panel (shows on hover)
+    __xb_preview = document.createElement('div');
+    __xb_preview.style.cssText = 'position:fixed;right:16px;top:50px;width:340px;max-height:60vh;overflow-y:auto;background:rgba(15,15,15,0.95);color:#e5e5e5;font:12px/1.5 system-ui,sans-serif;padding:12px;border-radius:8px;pointer-events:none;box-shadow:0 4px 20px rgba(0,0,0,0.5);display:none;';
+    __xb_overlay.appendChild(__xb_preview);
+
+    // Top hint bar
+    __xb_hint = document.createElement('div');
+    __xb_hint.style.cssText = 'position:fixed;top:12px;left:50%;transform:translateX(-50%);background:rgba(0,0,0,0.88);color:white;font:13px/1.4 system-ui,sans-serif;padding:8px 16px;border-radius:8px;pointer-events:none;white-space:nowrap;box-shadow:0 4px 16px rgba(0,0,0,0.3);';
+    __xb_hint.textContent = '\\u00b7  \\u00b7  \\u00b7';
+    __xb_overlay.appendChild(__xb_hint);
+
+    document.body.appendChild(__xb_overlay);
+    document.body.style.cursor = 'crosshair';
+  }
+
+  // \u2500\u2500 destroy overlay \u2500\u2500
+  function destroyOverlay() {
+    if (__xb_overlay && __xb_overlay.parentNode) {
+      __xb_overlay.parentNode.removeChild(__xb_overlay);
+    }
+    __xb_overlay = null;
+    __xb_highlight = null;
+    __xb_preview = null;
+    __xb_hint = null;
+    document.body.style.cursor = '';
+    __xb_hovered_el = null;
+  }
+
+  // \u2500\u2500 update highlight on mouse move \u2500\u2500
+  function updateHighlight(e) {
+    var el = document.elementFromPoint(e.clientX, e.clientY);
+    // Skip overlay elements
+    if (!el || (el.id && el.id.indexOf('__xb_') === 0) || (__xb_overlay && __xb_overlay.contains(el))) {
+      __xb_highlight.style.display = 'none';
+      __xb_preview.style.display = 'none';
+      __xb_hovered_el = null;
+      __xb_hint.textContent = '\\u5c06 \\u9f20\\u6807 \\u79fb\\u5230\\u60f3\\u6807\\u8bb0\\u7684\\u5143\\u7d20\\u4e0a';
+      return;
+    }
+    __xb_hovered_el = el;
+    var rect = el.getBoundingClientRect();
+
+    // Update highlight box
+    __xb_highlight.style.display = 'block';
+    __xb_highlight.style.left = (rect.left - 3) + 'px';
+    __xb_highlight.style.top = (rect.top - 3) + 'px';
+    __xb_highlight.style.width = (rect.width + 6) + 'px';
+    __xb_highlight.style.height = (rect.height + 6) + 'px';
+
+    // Build content preview
+    var content = getElementContent(el);
+    var sel = shortSelector(el);
+    var tag = tagLabel(el);
+    var html = '<div style="color:#888;margin-bottom:6px;font-size:11px;">' + sel + '</div>';
+    html += '<div style="color:#fff;font-weight:bold;margin-bottom:8px;">' + tag + '</div>';
+    if (content.length > 0) {
+      html += '<div style="border-top:1px solid #333;padding-top:8px;">';
+      for (var i = 0; i < Math.min(content.length, 15); i++) {
+        html += '<div style="padding:2px 0;color:#ccc;">\\u2022 ' + content[i].replace(/</g, '&lt;') + '</div>';
+      }
+      if (content.length > 15) html += '<div style="color:#666;">... +' + (content.length - 15) + ' more</div>';
+      html += '</div>';
+    }
+
+    __xb_preview.innerHTML = html;
+    __xb_preview.style.display = 'block';
+
+    // Update hint
+    __xb_hint.textContent = '\\u2461 \\u91c7\\u96c6\\u6b64\\u5143\\u7d20  \\u2462 \\u5361\\u70b9\\uff08\\u4eba\\u5de5\\u4ecb\\u5165\\uff09  \\u2502 \\u677e\\u5f00 Option \\u9000\\u51fa';
+  }
+
+  // \u2500\u2500 flash feedback \u2500\u2500
+  function flash(color) {
+    if (!__xb_highlight) return;
+    __xb_highlight.style.borderColor = color;
+    __xb_highlight.style.boxShadow = '0 0 24px ' + color + '80';
+    clearTimeout(__xb_flash_timer);
+    __xb_flash_timer = setTimeout(function() {
+      if (__xb_highlight) {
+        __xb_highlight.style.borderColor = '#3b82f6';
+        __xb_highlight.style.boxShadow = '0 0 12px rgba(59,130,246,0.5)';
+      }
+    }, 600);
+  }
+
+  // \u2500\u2500 push checkpoint to pending actions \u2500\u2500
+  function pushCheckpoint(mode) {
+    if (!__xb_hovered_el) return;
+    var el = __xb_hovered_el;
+    var content = getElementContent(el);
+    var sel = shortSelector(el);
+    var rect = el.getBoundingClientRect();
+
+    window.__xb_pending_actions = window.__xb_pending_actions || [];
+    window.__xb_pending_actions.push({
+      type: 'checkpoint',
+      ts: Date.now(),
+      url: location.href,
+      title: document.title,
+      checkpointType: mode === 'collect' ? 'collect' : 'blocker',
+      hint: mode === 'collect' ? '\\u91c7\\u96c6: ' + tagLabel(el) : '\\u5361\\u70b9: \\u9700\\u8981\\u4eba\\u5de5\\u4ecb\\u5165',
+      selector: sel,
+      source: 'manual',
+      category: mode,
+      content: content.join(' | '),
+      elementTag: el.tagName.toLowerCase(),
+      elementText: (el.textContent || '').trim().substring(0, 200),
+      rect: { x: Math.round(rect.left), y: Math.round(rect.top), w: Math.round(rect.width), h: Math.round(rect.height) },
+    });
+  }
+
+  // \u2500\u2500 event listeners \u2500\u2500
+  document.addEventListener('keydown', function(e) {
+    // Option/Alt pressed \u2192 enter marking mode
+    if (e.key === 'Alt' && !e.repeat && !__xb_active) {
+      __xb_active = true;
+      createOverlay();
+      e.preventDefault();
+      return;
+    }
+
+    // Only process keys while marking mode is active
+    if (!__xb_active) return;
+
+    // Press 1 \u2192 collect (capture element)
+    if (e.code === 'Digit1' || e.key === '1') {
+      pushCheckpoint('collect');
+      flash('#22c55e'); // green
+      e.preventDefault();
+      e.stopPropagation();
+      return;
+    }
+
+    // Press 2 \u2192 blocker (human intervention needed)
+    if (e.code === 'Digit2' || e.key === '2') {
+      pushCheckpoint('blocker');
+      flash('#ef4444'); // red
+      e.preventDefault();
+      e.stopPropagation();
+      return;
+    }
+  }, true);
+
+  document.addEventListener('keyup', function(e) {
+    if (e.key === 'Alt') {
+      __xb_active = false;
+      destroyOverlay();
+    }
+  }, true);
+
+  // Track mouse move (only when active)
+  document.addEventListener('mousemove', function(e) {
+    if (!__xb_active) return;
+    updateHighlight(e);
+  }, true);
+
+  // Prevent click while in marking mode
+  document.addEventListener('click', function(e) {
+    if (__xb_active) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+  }, true);
+})();
+`;
+var SessionRecorder = class _SessionRecorder {
+  context;
+  page;
+  sessionName;
+  startUrl = "";
+  startedAt = 0;
+  actions = [];
+  network = [];
+  contextChanges = [];
+  checkpoints = [];
+  actionCounter = 0;
+  networkCounter = 0;
+  contextCounter = 0;
+  checkpointCounter = 0;
+  pollTimer = null;
+  flushTimer = null;
+  lastActionTs = 0;
+  activePages = /* @__PURE__ */ new Set();
+  lastKnownUrl = "";
+  // Track URL to detect real navigation changes
+  /** Dedup window: after a CDP command action, ignore matching action signals within this window */
+  cdpActionDedup = null;
+  /** Network dedup: last request key for short-window dedup */
+  _lastRequestKey = "";
+  _lastRequestTs = 0;
+  _isRecording = false;
+  constructor(context, page, sessionName) {
+    this.context = context;
+    this.page = page;
+    this.sessionName = sessionName;
+  }
+  get isRecording() {
+    return this._isRecording;
+  }
+  get actionCount() {
+    return this.actions.length;
+  }
+  /** Record an action triggered by a CDP command (e.g. xbrowser fill/click/goto) */
+  recordCommandAction(action) {
+    const normalizedType = action.type === "cdp-fill" ? "input" : action.type === "cdp-click" ? "click" : action.type;
+    const recent = this.actions[this.actions.length - 1];
+    if (recent && Date.now() - recent.timestamp < 1500) {
+      const typeMatch = recent.type === action.type || recent.type === normalizedType;
+      const valueMatch = !action.value || recent.value === action.value;
+      const selectorMatch = !action.selector || recent.element?.selector && (recent.element.selector === action.selector || recent.element.selector.endsWith(" " + action.selector) || action.selector.endsWith(" " + recent.element.selector));
+      if (typeMatch && valueMatch && selectorMatch) {
+        return;
+      }
+    }
+    this.actionCounter++;
+    const ts = Date.now();
+    const actionUrl = action.url && action.url !== "about:blank" ? action.url : this.lastKnownUrl || this.page.url();
+    this.actions.push({
+      id: this.actionCounter,
+      type: action.type,
+      timestamp: ts,
+      url: actionUrl,
+      pageTitle: "",
+      element: action.element || (action.selector ? { tag: "", selector: action.selector, text: "" } : void 0),
+      value: action.value
+    });
+    this.lastActionTs = ts;
+    this.cdpActionDedup = {
+      type: normalizedType,
+      value: action.value,
+      selector: action.selector,
+      until: Date.now() + 1500
+    };
+    if (action.url && action.url !== "about:blank") {
+      this.lastKnownUrl = action.url;
+    } else if (action.type === "goto" && action.value && action.value !== "about:blank") {
+      this.lastKnownUrl = action.value;
+    }
+  }
+  get networkCount() {
+    return this.network.length;
+  }
+  getLiveData() {
+    return this.buildData();
+  }
+  addManualCheckpoint(type, hint, selector) {
+    this.checkpointCounter++;
+    const cp = {
+      id: this.checkpointCounter,
+      type,
+      timestamp: Date.now(),
+      url: this.page.url(),
+      pageTitle: "",
+      hint,
+      selector,
+      source: "manual"
+    };
+    this.checkpoints.push(cp);
+    return cp;
+  }
+  /** Directory for this session's recordings. */
+  get recordingsDir() {
+    return _SessionRecorder.getRecordingsDir(this.sessionName);
+  }
+  static getRecordingsDir(sessionName) {
+    return join2(homedir2(), ".xbrowser", "sessions", sessionName, "recordings");
+  }
+  /** Path to the control file (used by record stop to signal this process). */
+  get controlFilePath() {
+    return join2(this.recordingsDir, ".control.json");
+  }
+  /** Path to the stop signal file (written by `record stop`). */
+  get stopSignalPath() {
+    return join2(this.recordingsDir, ".stop");
+  }
+  // ─── Start ──────────────────────────────────────────────────────
+  async start(url) {
+    if (this._isRecording) throw new Error("Already recording");
+    this._isRecording = true;
+    this.startedAt = Date.now();
+    this.actions = [];
+    this.network = [];
+    this.contextChanges = [];
+    this.checkpoints = [];
+    this.checkpointCounter = 0;
+    this.lastKnownUrl = this.page.url();
+    await this.page.addInitScript(getSelectorGeneratorScript());
+    await this.page.addInitScript(ACTION_SIGNAL_SCRIPT);
+    await this.page.addInitScript(CHECKPOINT_OVERLAY_SCRIPT);
+    if (url) {
+      await this.page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+      this.startUrl = url;
+    } else {
+      this.startUrl = this.page.url();
+    }
+    mkdirSync2(this.recordingsDir, { recursive: true });
+    const control = {
+      pid: process.pid,
+      startedAt: new Date(this.startedAt).toISOString(),
+      startUrl: this.startUrl,
+      sessionName: this.sessionName
+    };
+    writeFileSync2(this.controlFilePath, JSON.stringify(control, null, 2), "utf-8");
+    await this.injectActionScript(this.page);
+    this.context.on("request", this.handleRequest);
+    this.context.on("response", this.handleResponse);
+    this.context.on("page", this.handleNewPage);
+    for (const p of this.context.pages()) {
+      p.on("request", this.handleRequest);
+      p.on("response", this.handleResponse);
+    }
+    this.context.on("page", this.handleNewPage);
+    this.page.on("framenavigated", this.handleFrameNavigated);
+    this.page.on("dialog", this.handleDialog);
+    this.page.on("filechooser", this.handleFileChooser);
+    this.pollTimer = setInterval(() => void this.pollActions(), 200);
+    this.flushTimer = setInterval(() => this.flushToDisk(), 5e3);
+  }
+  // ─── Stop ───────────────────────────────────────────────────────
+  async stop() {
+    if (!this._isRecording) throw new Error("Not recording");
+    this._isRecording = false;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.context.off("request", this.handleRequest);
+    this.context.off("response", this.handleResponse);
+    this.context.off("page", this.handleNewPage);
+    this.page.off("framenavigated", this.handleFrameNavigated);
+    this.page.off("dialog", this.handleDialog);
+    for (const p of this.activePages) {
+      try {
+        p.off("framenavigated", this.handleFrameNavigated);
+      } catch {
+      }
+    }
+    await this.flushPendingActions(this.page);
+    for (const p of this.activePages) {
+      await this.flushPendingActions(p).catch(() => {
+      });
+    }
+    const data = this.buildData();
+    const summary = this.buildSummary(data);
+    this.writeFinalOutput(data, summary);
+    try {
+      const knowledge = updateSiteKnowledge(data);
+      const knowledgeDir = join2(this.recordingsDir, "site-knowledge.md");
+      const knowledgeJson = join2(this.recordingsDir, "site-knowledge.json");
+      const { readFileSync: rf } = __require("fs");
+      const { getKnowledgePath: getKnowledgePath2 } = (init_site_knowledge(), __toCommonJS(site_knowledge_exports));
+      const mdPath = getKnowledgePath2(knowledge.domain, "md");
+      try {
+        const md = rf(mdPath, "utf-8");
+        writeFileSync2(knowledgeDir, md, "utf-8");
+      } catch {
+      }
+      writeFileSync2(knowledgeJson, JSON.stringify(knowledge, null, 2), "utf-8");
+    } catch {
+    }
+    try {
+      rmSync(this.controlFilePath);
+    } catch {
+    }
+    try {
+      rmSync(this.stopSignalPath);
+    } catch {
+    }
+    return { data, summary };
+  }
+  // ─── Cleanup (called on session close) ──────────────────────────
+  static cleanup(sessionName) {
+    const dir = _SessionRecorder.getRecordingsDir(sessionName);
+    if (existsSync2(dir)) {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+  // ─── Wait for stop signal (blocks the process) ──────────────────
+  waitForStopSignal() {
+    return new Promise((resolve) => {
+      const check = () => {
+        if (existsSync2(this.stopSignalPath)) {
+          resolve();
+        } else {
+          setTimeout(check, 300);
+        }
+      };
+      check();
+    });
+  }
+  // ─── Static: send stop signal to a running recorder ─────────────
+  static async sendStopSignal(sessionName) {
+    const dir = _SessionRecorder.getRecordingsDir(sessionName);
+    const controlPath = join2(dir, ".control.json");
+    const stopPath = join2(dir, ".stop");
+    if (!existsSync2(controlPath)) return null;
+    const control = JSON.parse(readFileSync2(controlPath, "utf-8"));
+    let alive = false;
+    try {
+      process.kill(control.pid, 0);
+      alive = true;
+    } catch {
+      alive = false;
+    }
+    if (!alive) {
+      try {
+        rmSync(controlPath);
+      } catch {
+      }
+      return control;
+    }
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(stopPath, JSON.stringify({ stoppedAt: (/* @__PURE__ */ new Date()).toISOString() }), "utf-8");
+    for (let i = 0; i < 50; i++) {
+      await new Promise((r) => setTimeout(r, 200));
+      if (!existsSync2(controlPath)) return control;
+      try {
+        process.kill(control.pid, 0);
+      } catch {
+        try {
+          rmSync(controlPath);
+        } catch {
+        }
+        return control;
+      }
+    }
+    try {
+      rmSync(controlPath);
+    } catch {
+    }
+    return control;
+  }
+  // ─── Static: read recording from disk ───────────────────────────
+  static readSummary(sessionName) {
+    const path = join2(_SessionRecorder.getRecordingsDir(sessionName), "summary.json");
+    try {
+      return JSON.parse(readFileSync2(path, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  static readData(sessionName) {
+    const path = join2(_SessionRecorder.getRecordingsDir(sessionName), "recording.json");
+    try {
+      return JSON.parse(readFileSync2(path, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  // ==================== Private ====================
+  async injectActionScript(page) {
+    try {
+      await page.evaluate(getSelectorGeneratorScript());
+      await page.evaluate(ACTION_SIGNAL_SCRIPT);
+      await page.evaluate(`window.__xb_action_script_src = ${JSON.stringify(ACTION_SIGNAL_SCRIPT)};`);
+    } catch {
+    }
+    try {
+      await page.evaluate(CHECKPOINT_OVERLAY_SCRIPT);
+    } catch {
+    }
+    try {
+      await page.evaluate(`
+        (function() {
+          var _scriptSrc = ${JSON.stringify(ACTION_SIGNAL_SCRIPT)};
+          function injectIframe(iframe) {
+            try {
+              var w = iframe.contentWindow;
+              if (!w) return;
+              // Force re-injection: clear old flag
+              try { delete w.__xb_action_signal; } catch(e) {}
+              w.eval(_scriptSrc);
+              // Tag iframe so flushIframes knows it's injected
+              iframe.__xb_injected = true;
+            } catch(e) {}
+          }
+          function watchIframe(iframe) {
+            if (iframe.__xb_watched) return;
+            iframe.__xb_watched = true;
+            injectIframe(iframe);
+            iframe.addEventListener('load', function() { injectIframe(iframe); });
+          }
+          // Inject into existing iframes
+          try {
+            var iframes = document.querySelectorAll('iframe');
+            for (var i = 0; i < iframes.length; i++) watchIframe(iframes[i]);
+          } catch(e) {}
+          // Watch for dynamically inserted iframes
+          if (!window.__xb_iframe_observer) {
+            window.__xb_iframe_observer = new MutationObserver(function(mutations) {
+              for (var m = 0; m < mutations.length; m++) {
+                for (var n = 0; n < mutations[m].addedNodes.length; n++) {
+                  var node = mutations[m].addedNodes[n];
+                  if (node.tagName === 'IFRAME') {
+                    watchIframe(node);
+                  } else if (node.querySelectorAll) {
+                    var sub = node.querySelectorAll('iframe');
+                    for (var k = 0; k < sub.length; k++) watchIframe(sub[k]);
+                  }
+                }
+              }
+            });
+            window.__xb_iframe_observer.observe(document.documentElement, { childList: true, subtree: true });
+          }
+          // Periodic re-injection for iframes that load late or navigate internally
+          if (!window.__xb_iframe_timer) {
+            window.__xb_iframe_timer = setInterval(function() {
+              try {
+                var iframes = document.querySelectorAll('iframe');
+                for (var i = 0; i < iframes.length; i++) {
+                  if (!iframes[i].__xb_injected) {
+                    watchIframe(iframes[i]);
+                  }
+                }
+              } catch(e) {}
+            }, 3000);
+          }
+        })();
+      `);
+    } catch {
+    }
+  }
+  // ─── Network capture ────────────────────────────────────────────
+  handleRequest = (request) => {
+    const resourceType = request.resourceType();
+    if (["image", "stylesheet", "font", "manifest", "other"].includes(resourceType)) return;
+    const url = request.url();
+    if (url.startsWith("data:") || url.startsWith("chrome-extension://") || url.startsWith("blob:")) return;
+    const dedupKey = request.method() + " " + url;
+    const now = Date.now();
+    if (this._lastRequestKey === dedupKey && now - this._lastRequestTs < 100) return;
+    this._lastRequestKey = dedupKey;
+    this._lastRequestTs = now;
+    this.networkCounter++;
+    const entry = {
+      id: this.networkCounter,
+      timestamp: Date.now(),
+      method: request.method(),
+      url,
+      path: new URL(url).pathname,
+      status: 0,
+      resourceType,
+      contentType: "",
+      responseSize: 0
+    };
+    if (["POST", "PATCH", "PUT"].includes(request.method())) {
+      try {
+        const postData = request.postData();
+        if (postData) {
+          try {
+            entry.requestBody = JSON.parse(postData);
+          } catch {
+            entry.requestBody = postData.substring(0, 500);
+          }
+        }
+      } catch {
+      }
+    }
+    this.network.push(entry);
+  };
+  handleResponse = async (response) => {
+    const url = response.url();
+    if (url.startsWith("data:") || url.startsWith("chrome-extension://") || url.startsWith("blob:")) return;
+    const entry = [...this.network].reverse().find((e) => e.url === url && e.status === 0);
+    if (!entry) return;
+    entry.status = response.status();
+    entry.contentType = response.headers()["content-type"] || "";
+    const resourceType = response.request().resourceType();
+    const isApi = ["fetch", "xhr"].includes(resourceType) || entry.contentType.includes("json") || entry.contentType.includes("text/");
+    if (isApi) {
+      try {
+        const text = await response.text();
+        entry.responseSize = text.length;
+        if (text.length <= 20480) {
+          try {
+            entry.responseBody = JSON.parse(text);
+          } catch {
+            entry.responseBody = text.substring(0, 500);
+          }
+        }
+      } catch {
+      }
+    } else {
+      try {
+        entry.responseSize = parseInt(response.headers()["content-length"] || "0", 10);
+      } catch {
+      }
+    }
+  };
+  // ─── Page tracking ──────────────────────────────────────────────
+  handleNewPage = async (page) => {
+    this.activePages.add(page);
+    this.contextCounter++;
+    this.contextChanges.push({
+      id: this.contextCounter,
+      timestamp: Date.now(),
+      type: "new_tab",
+      url: page.url(),
+      detail: "New tab/popup opened"
+    });
+    await page.addInitScript(ACTION_SIGNAL_SCRIPT);
+    await page.addInitScript(CHECKPOINT_OVERLAY_SCRIPT);
+    await page.addInitScript(getSelectorGeneratorScript());
+    const injectAndRetry = async () => {
+      for (let attempt = 0; attempt < 5; attempt++) {
+        try {
+          const url = page.url();
+          if (url && url !== "about:blank" && !url.startsWith("chrome")) {
+            await this.injectActionScript(page);
+            return;
+          }
+        } catch {
+        }
+        await new Promise((r) => setTimeout(r, 1e3));
+      }
+    };
+    injectAndRetry();
+    page.on("framenavigated", this.handleFrameNavigated);
+    page.on("request", this.handleRequest);
+    page.on("response", this.handleResponse);
+    page.on("filechooser", this.handleFileChooser);
+    page.on("dialog", this.handleDialog);
+    page.on("close", () => {
+      this.activePages.delete(page);
+    });
+    page.on("framenavigated", async (frame) => {
+      if (frame !== frame.page().mainFrame()) return;
+      const url = frame.url();
+      if (url && url !== "about:blank" && !url.startsWith("chrome")) {
+        try {
+          await this.injectActionScript(page);
+        } catch {
+        }
+      }
+    });
+  };
+  handleFrameNavigated = (frame) => {
+    if (frame !== frame.page().mainFrame()) return;
+    const newUrl = frame.url();
+    this.contextCounter++;
+    this.contextChanges.push({
+      id: this.contextCounter,
+      timestamp: Date.now(),
+      type: "navigate",
+      url: newUrl
+    });
+    const lastAction = this.actions[this.actions.length - 1];
+    const lastActionUrl = lastAction?.url;
+    if (newUrl && newUrl !== "about:blank" && newUrl !== lastActionUrl) {
+      this.actionCounter++;
+      this.actions.push({
+        id: this.actionCounter,
+        type: "navigation",
+        timestamp: Date.now(),
+        url: newUrl,
+        pageTitle: "",
+        element: void 0
+      });
+    }
+    const page = frame.page();
+    if (newUrl && newUrl !== "about:blank") {
+      this.injectActionScript(page).catch(() => {
+      });
+    }
+  };
+  handleDialog = async (dialog) => {
+    this.checkpointCounter++;
+    this.checkpoints.push({
+      id: this.checkpointCounter,
+      type: "dialog",
+      timestamp: Date.now(),
+      url: this.page.url(),
+      pageTitle: await this.page.title().catch(() => ""),
+      hint: `Dialog [${dialog.type}]: "${dialog.message()}"`,
+      source: "auto",
+      context: { dialogType: dialog.type, message: dialog.message() }
+    });
+    await dialog.dismiss().catch(() => {
+    });
+  };
+  handleFileChooser = async (fileChooser) => {
+    const url = this.page.url();
+    const sel = fileChooser.selector || 'input[type="file"]';
+    let element;
+    try {
+      element = await this.page.evaluate(new Function("selector", `
+        const el = document.querySelector(selector);
+        if (!el) return null;
+        return window.__xb_describe(el);
+      `), sel) ?? void 0;
+    } catch {
+    }
+    let fileData = [];
+    try {
+      fileData = await this.page.evaluate(new Function("selector", `
+        return new Promise(resolve => {
+          const input = document.querySelector(selector);
+          if (!input || !input.files || input.files.length === 0) { resolve([]); return; }
+          const readers = [];
+          for (let i = 0; i < input.files.length; i++) {
+            readers.push(new Promise(r => {
+              const reader = new FileReader();
+              reader.onload = () => r({ name: input.files[i].name, type: input.files[i].type, size: input.files[i].size, dataUrl: reader.result });
+              reader.onerror = () => r({ name: input.files[i].name, type: input.files[i].type, size: input.files[i].size, dataUrl: null });
+              reader.readAsDataURL(input.files[i]);
+            }));
+          }
+          Promise.all(readers).then(resolve);
+        });
+      `), sel);
+    } catch {
+    }
+    const names = fileData.map((f) => f.name);
+    this.actionCounter++;
+    this.actions.push({
+      id: this.actionCounter,
+      type: "filechooser",
+      timestamp: Date.now(),
+      url,
+      pageTitle: "",
+      element: element || {
+        selector: sel,
+        strategy: "css",
+        confidence: "high",
+        tag: "input",
+        text: ""
+      },
+      value: names.join(", ") || void 0,
+      files: {
+        names,
+        count: fileData.length,
+        isMultiple: fileChooser.isMultiple,
+        fileData: fileData.length > 0 ? fileData : void 0
+      }
+    });
+  };
+  // ─── Action polling ─────────────────────────────────────────────
+  async pollActions() {
+    const pages = [this.page, ...this.activePages];
+    for (const page of pages) {
+      try {
+        if (page.isClosed()) continue;
+        await this.flushPendingActions(page);
+      } catch {
+      }
+    }
+  }
+  async flushPendingActions(page) {
+    let pending = [];
+    try {
+      pending = await page.evaluate(`(function() {
+        var w = window;
+        var actions = w.__xb_pending_actions || [];
+        w.__xb_pending_actions = [];
+
+        // Recursively flush pending actions from same-origin iframes (including nested)
+        function flushIframes(doc) {
+          try {
+            var iframes = doc.querySelectorAll('iframe');
+            for (var i = 0; i < iframes.length; i++) {
+              try {
+                var iframeWin = iframes[i].contentWindow;
+                if (!iframeWin) continue;
+                // Ensure action script is injected into iframe
+                if (!iframeWin.__xb_action_script_injected) {
+                  iframeWin.__xb_action_script_injected = true;
+                  try { delete iframeWin.__xb_action_signal; } catch(e) {}
+                  try { iframeWin.eval(w.__xb_action_script_src); } catch(e) {}
+                }
+                var iframeActions = iframeWin.__xb_pending_actions;
+                if (Array.isArray(iframeActions) && iframeActions.length > 0) {
+                  // Get iframe position to offset coordinates
+                  var rect = iframes[i].getBoundingClientRect();
+                  for (var j = 0; j < iframeActions.length; j++) {
+                    var act = iframeActions[j];
+                    // Offset coordinates from iframe-relative to page-relative
+                    if (act.x != null) act.x = act.x + rect.left;
+                    if (act.y != null) act.y = act.y + rect.top;
+                    // Tag the action as originating from an iframe
+                    act.iframeSrc = iframes[i].src || '';
+                    actions.push(act);
+                  }
+                  iframeWin.__xb_pending_actions = [];
+                }
+                // Recurse into nested iframes
+                try { flushIframes(iframeWin.document); } catch(e) {}
+              } catch(e) {}
+            }
+          } catch(e) {}
+        }
+
+        flushIframes(document);
+        return actions;
+      })()`);
+    } catch {
+      return;
+    }
+    try {
+      const currentUrl = page.url();
+      const normalize = (u) => u.replace(/\/+$/, "");
+      if (currentUrl && currentUrl !== "about:blank" && normalize(currentUrl) !== normalize(this.lastKnownUrl)) {
+        const hasNav = this.actions.slice(-3).some(
+          (a) => (a.type === "navigation" || a.type === "goto") && normalize(a.url || "") === normalize(currentUrl)
+        );
+        if (!hasNav) {
+          this.actionCounter++;
+          this.actions.push({
+            id: this.actionCounter,
+            type: "navigation",
+            timestamp: Date.now(),
+            url: currentUrl,
+            pageTitle: "",
+            element: void 0
+          });
+        }
+        this.lastKnownUrl = currentUrl;
+      }
+    } catch {
+    }
+    for (const raw of pending) {
+      if (raw.ts <= this.lastActionTs) continue;
+      if (this.cdpActionDedup && Date.now() < this.cdpActionDedup.until) {
+        const dedup = this.cdpActionDedup;
+        const typeMatch = raw.type === dedup.type;
+        const valueMatch = !dedup.value || raw.value === dedup.value;
+        const selectorMatch = !dedup.selector || raw.element?.selector && (raw.element.selector === dedup.selector || raw.element.selector.endsWith(" " + dedup.selector) || dedup.selector.endsWith(" " + raw.element.selector));
+        if (typeMatch && valueMatch && selectorMatch) {
+          continue;
+        }
+      }
+      this.actionCounter++;
+      let clickContext;
+      if (raw.type === "click" && raw.x !== void 0 && raw.y !== void 0) {
+        clickContext = await this.captureClickContext(page, raw.x, raw.y);
+      }
+      this.actions.push({
+        id: this.actionCounter,
+        type: raw.type,
+        timestamp: raw.ts,
+        url: raw.url || page.url(),
+        pageTitle: raw.title || "",
+        element: raw.element,
+        value: raw.value,
+        key: raw.key,
+        x: raw.x,
+        y: raw.y,
+        scrollX: raw.scrollX,
+        scrollY: raw.scrollY,
+        clickContext,
+        files: raw.files
+      });
+      this.lastActionTs = raw.ts;
+      if (raw.type === "click" || raw.type === "navigate" || raw.type === "submit") {
+        const detected = await this.detectCheckpoints(page);
+        for (const cp of detected) {
+          cp.relatedActionId = this.actionCounter;
+          this.checkpoints.push(cp);
+        }
+      }
+    }
+  }
+  /**
+   * After a click, wait 300ms then scan for popover/dropdown/menu elements
+   * near the click position. This runs server-side to avoid race conditions
+   * with the client-side poll interval.
+   */
+  async captureClickContext(page, cx, cy) {
+    await new Promise((r) => setTimeout(r, 300));
+    try {
+      const ctx = await page.evaluate(`
+        (function() {
+          var cx = ${cx}, cy = ${cy};
+          var POPOVER_SELECTORS = [
+            '[role="menu"]','[role="listbox"]','[role="dialog"]','[role="tooltip"]','[role="popover"]',
+            '[role="combobox"]','[role="tree"]','[role="grid"]',
+            '.popover','.popup','.dropdown','.menu','.modal','.tooltip','.panel',
+            '[class*="popover"]','[class*="popup"]','[class*="dropdown"]','[class*="menu"]',
+            '[class*="tooltip"]','[class*="modal"]','[class*="panel"]','[class*="overlay"]','[class*="sheet"]',
+            '[data-popup]','[data-dropdown]','[data-menu]','[data-popover"]',
+            '.semi-dropdown','.semi-popover','.semi-modal',
+            '.ant-dropdown','.ant-popover','.ant-modal',
+            '.el-dropdown','.el-popover','.el-dialog',
+            '.t-dropdown','.t-popup','.t-dialog'
+          ];
+
+          function isNear(el, x, y, range) {
+            try {
+              var r = el.getBoundingClientRect();
+              if (!r || r.width === 0 || r.height === 0) return false;
+              return !(r.left > x + range || r.right < x - range || r.top > y + range || r.bottom < y - range);
+            } catch(e) { return false; }
+          }
+
+          var result = { appeared: [], disappeared: [], stateChanges: [] };
+          var seenElements = new Set();
+
+          for (var si = 0; si < POPOVER_SELECTORS.length; si++) {
+            try {
+              var els = document.querySelectorAll(POPOVER_SELECTORS[si]);
+              for (var j = 0; j < els.length; j++) {
+                var el = els[j];
+                if (seenElements.has(el)) continue;
+                if (!isNear(el, cx, cy, 300)) continue;
+                var rect = el.getBoundingClientRect();
+                if (rect.width === 0 || rect.height === 0) continue;
+                seenElements.add(el);
+
+                var items = [];
+                var children = el.querySelectorAll('a,button,[role="menuitem"],[role="option"],[role="treeitem"],li,div[class*="item"]');
+                var seenItemTexts = new Set();
+                for (var k = 0; k < Math.min(children.length, 30); k++) {
+                  var child = children[k];
+                  var childText = (child.textContent || '').trim().substring(0, 60);
+                  if (!childText || seenItemTexts.has(childText)) continue;
+                  seenItemTexts.add(childText);
+                  var ci = { text: childText };
+                  try { if (child.disabled || child.getAttribute('aria-disabled') === 'true') ci.disabled = true; } catch(e) {}
+                  try { if (child.tagName) ci.tag = child.tagName.toLowerCase(); } catch(e) {}
+                  try { if (child.href) ci.href = child.href.substring(0, 80); } catch(e) {}
+                  items.push(ci);
+                }
+
+                result.appeared.push({
+                  tag: el.tagName.toLowerCase(),
+                  selector: el.id ? '#' + el.id : undefined,
+                  role: el.getAttribute('role'),
+                  text: (el.textContent || '').trim().substring(0, 100),
+                  rect: { x: Math.round(rect.x), y: Math.round(rect.y), w: Math.round(rect.width), h: Math.round(rect.height) },
+                  items: items
+                });
+              }
+            } catch(e) { /* skip invalid selectors */ }
+          }
+
+          var allInteractive = document.querySelectorAll('[aria-expanded],[disabled],[aria-disabled],[aria-selected],[data-state]');
+          for (var i = 0; i < allInteractive.length; i++) {
+            var el2 = allInteractive[i];
+            if (!isNear(el2, cx, cy, 200)) continue;
+            var info = { tag: el2.tagName.toLowerCase(), text: (el2.textContent || '').trim().substring(0, 60) };
+            try { if (el2.id) info.id = el2.id; } catch(e) {}
+            try { if (el2.getAttribute('aria-expanded')) info.ariaExpanded = el2.getAttribute('aria-expanded'); } catch(e) {}
+            try { if (el2.disabled || el2.getAttribute('aria-disabled') === 'true') info.disabled = true; } catch(e) {}
+            try { if (el2.getAttribute('aria-selected')) info.ariaSelected = el2.getAttribute('aria-selected'); } catch(e) {}
+            try { if (el2.getAttribute('data-state')) info.dataState = el2.getAttribute('data-state'); } catch(e) {}
+            result.stateChanges.push(info);
+          }
+
+          return result;
+        })()
+      `);
+      if (ctx.appeared.length > 0 || ctx.stateChanges.length > 0) {
+        return ctx;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  async detectCheckpoints(page) {
+    const CHECKPOINT_RULES = [
+      { type: "captcha", selectors: ['img[src*="captcha"]', 'img[src*="verify"]', '[class*="captcha"]', '[id*="captcha"]', "#captcha", ".captcha"] },
+      { type: "slider", selectors: ['[class*="slider"]', '[class*="drag-verify"]', '[class*="slide-verify"]'] },
+      { type: "login", selectors: ['input[type="password"]'] },
+      { type: "iframe", selectors: ['iframe[src*="captcha"]', 'iframe[src*="verify"]', 'iframe[src*="recaptcha"]', 'iframe[title*="captcha"]'] }
+    ];
+    try {
+      const found = await page.evaluate((rules) => {
+        const results = [];
+        for (const rule of rules) {
+          for (const sel of rule.selectors) {
+            try {
+              const el = document.querySelector(sel);
+              if (el) {
+                const rect = el.getBoundingClientRect();
+                if (rect.width > 0 && rect.height > 0) {
+                  results.push({
+                    type: rule.type,
+                    selector: sel,
+                    text: (el.textContent || "").substring(0, 60)
+                  });
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        return results;
+      }, CHECKPOINT_RULES);
+      const entries = [];
+      for (const item of found) {
+        this.checkpointCounter++;
+        const hints = {
+          captcha: "Captcha verification detected",
+          slider: "Slider verification detected",
+          login: "Login form detected (password field)",
+          iframe: "Verification iframe detected"
+        };
+        entries.push({
+          id: this.checkpointCounter,
+          type: item.type,
+          timestamp: Date.now(),
+          url: page.url(),
+          pageTitle: await page.title().catch(() => ""),
+          hint: hints[item.type] || item.type,
+          selector: item.selector,
+          source: "auto",
+          context: { matchedSelector: item.selector, elementText: item.text }
+        });
+      }
+      return entries;
+    } catch {
+      return [];
+    }
+  }
+  // ─── Periodic disk flush ────────────────────────────────────────
+  flushToDisk() {
+    const data = this.buildData();
+    try {
+      writeFileSync2(
+        join2(this.recordingsDir, "recording.json"),
+        JSON.stringify(data, null, 2),
+        "utf-8"
+      );
+    } catch {
+    }
+  }
+  writeFinalOutput(data, summary) {
+    mkdirSync2(this.recordingsDir, { recursive: true });
+    writeFileSync2(join2(this.recordingsDir, "recording.json"), JSON.stringify(data, null, 2), "utf-8");
+    writeFileSync2(join2(this.recordingsDir, "summary.json"), JSON.stringify(summary, null, 2), "utf-8");
+    writeFileSync2(join2(this.recordingsDir, "summary.md"), this.buildMarkdownSummary(data, summary), "utf-8");
+  }
+  buildData() {
+    return {
+      startUrl: this.startUrl,
+      sessionName: this.sessionName,
+      startedAt: new Date(this.startedAt).toISOString(),
+      actions: [...this.actions],
+      network: [...this.network],
+      contextChanges: [...this.contextChanges],
+      checkpoints: [...this.checkpoints]
+    };
+  }
+  // ─── Summary builder with ref compression + input→network matching ──
+  buildSummary(data) {
+    const POST_WINDOW = 5e3;
+    const MERGE_WINDOW = 2e3;
+    const steps = [];
+    const selectorToRef = /* @__PURE__ */ new Map();
+    const elements = {};
+    let refCounter = 0;
+    function getRef(action) {
+      const sel = action.element?.selector || action.element?.tag || "_none";
+      if (selectorToRef.has(sel)) return selectorToRef.get(sel);
+      refCounter++;
+      const ref = "e" + refCounter;
+      selectorToRef.set(sel, ref);
+      if (action.element) {
+        elements[ref] = {
+          selector: action.element.selector || action.element.tag,
+          tag: action.element.tag,
+          text: action.element.text,
+          role: action.element.role,
+          type: action.element.type,
+          placeholder: action.element.placeholder,
+          ariaLabel: action.element.ariaLabel,
+          href: action.element.href
+        };
+      } else {
+        elements[ref] = { selector: "_none", tag: "_", text: "" };
+      }
+      return ref;
+    }
+    const isNoiseNetwork = (n) => {
+      const url = n.url || "";
+      const path = n.path || "";
+      const rt = n.resourceType || "";
+      if (["image", "stylesheet", "font", "manifest", "other"].includes(rt)) return true;
+      if (n.status === 0) return true;
+      if (/\/ztbox|\/mwb2\.gif|\/hmslog|\/log\.gif|\/tongji|hm\.baidu|clickstream|\/actionlog|\/collect\?|\/track|\/beacon/i.test(url)) return true;
+      if (/\/favicon\.ico|\/robots\.txt/i.test(path)) return true;
+      return false;
+    };
+    const meaningfulNetwork = data.network.filter((n) => !isNoiseNetwork(n));
+    const filtered = data.actions.filter((a) => a.type !== "scroll");
+    const groups = [];
+    let current = null;
+    for (const action of filtered) {
+      const sameElement = current && current.primary.element?.selector && current.primary.element.selector === action.element?.selector && action.timestamp - current.primary.timestamp < MERGE_WINDOW;
+      const isInputLike = action.type === "input" || action.type === "keydown" || action.type === "change";
+      if (current && (sameElement || isInputLike && current.actions.some((a) => a.type === "input" || a.type === "click") && action.timestamp - current.primary.timestamp < MERGE_WINDOW)) {
+        current.actions.push(action);
+        if (action.type === "input") current.primary = action;
+      } else {
+        current = { actions: [action], primary: action };
+        groups.push(current);
+      }
+    }
+    for (const group of groups) {
+      const primary = group.primary;
+      const tsStart = Math.min(...group.actions.map((a) => a.timestamp));
+      const tsEnd = Math.max(...group.actions.map((a) => a.timestamp));
+      const inputAction = group.actions.find((a) => a.type === "input");
+      const nearbyNetwork = meaningfulNetwork.filter(
+        (n) => n.timestamp >= tsStart - 500 && n.timestamp <= tsEnd + POST_WINDOW
+      );
+      const nearbyContext = data.contextChanges.filter(
+        (c) => c.timestamp >= tsStart - 500 && c.timestamp <= tsEnd + POST_WINDOW
+      );
+      const matchedInputs = inputAction ? this.matchActionToNetwork(inputAction, nearbyNetwork) : [];
+      const clickMatches = primary.type === "click" && primary.element?.text ? this.matchActionToNetwork(primary, nearbyNetwork) : [];
+      steps.push({
+        step: steps.length + 1,
+        ref: getRef(primary),
+        action: primary,
+        network: nearbyNetwork.map((n) => ({
+          ...n,
+          responseBody: n.responseBody && JSON.stringify(n.responseBody).length > 1e3 ? "[truncated, " + JSON.stringify(n.responseBody).length + " bytes]" : n.responseBody
+        })),
+        contextChanges: nearbyContext,
+        matchedInputs: [...matchedInputs, ...clickMatches]
+      });
+    }
+    return {
+      startUrl: data.startUrl,
+      recordedAt: new Date(this.startedAt).toISOString(),
+      durationMs: Date.now() - this.startedAt,
+      totalActions: data.actions.length,
+      totalNetworkRequests: meaningfulNetwork.length,
+      steps,
+      elements,
+      checkpoints: data.checkpoints
+    };
+  }
+  matchActionToNetwork(action, nearbyNetwork) {
+    const matches = [];
+    const searchValue = (action.value || action.element?.text || "").trim();
+    if (!searchValue || searchValue.length < 2) return matches;
+    for (const netEntry of nearbyNetwork) {
+      if (netEntry.url.includes(encodeURIComponent(searchValue)) || netEntry.url.includes(searchValue)) {
+        matches.push({ inputValue: searchValue, networkId: netEntry.id, paramName: "url" });
+      }
+      if (netEntry.requestBody && typeof netEntry.requestBody === "object") {
+        this.searchObjectForValue(
+          netEntry.requestBody,
+          searchValue,
+          netEntry.id,
+          "",
+          matches
+        );
+      }
+    }
+    return matches;
+  }
+  searchObjectForValue(obj, targetValue, networkId, prefix, results) {
+    for (const [key, value] of Object.entries(obj)) {
+      const fullKey = prefix ? `${prefix}.${key}` : key;
+      if (typeof value === "string" && value.includes(targetValue)) {
+        results.push({ inputValue: targetValue, networkId, paramName: fullKey });
+      } else if (typeof value === "object" && value !== null) {
+        this.searchObjectForValue(value, targetValue, networkId, fullKey, results);
+      }
+    }
+  }
+  buildMarkdownSummary(_data, summary) {
+    const lines = [];
+    const durSec = Math.round(summary.durationMs / 1e3);
+    lines.push("# Recording Summary");
+    lines.push("");
+    lines.push(`- **URL**: ${summary.startUrl}`);
+    lines.push(`- **Recorded**: ${summary.recordedAt}`);
+    lines.push(`- **Duration**: ${durSec}s`);
+    lines.push(`- **Steps**: ${summary.totalActions} actions, ${summary.totalNetworkRequests} network requests`);
+    if (summary.checkpoints.length > 0) {
+      const cpTypes = summary.checkpoints.map((c) => c.type);
+      lines.push(`- **Checkpoints**: ${summary.checkpoints.length} (${[...new Set(cpTypes)].join(", ")})`);
+    } else {
+      lines.push("- **Checkpoints**: 0");
+    }
+    const checkpointSteps = /* @__PURE__ */ new Map();
+    for (const cp of summary.checkpoints) {
+      if (cp.relatedActionId != null) {
+        for (const step of summary.steps) {
+          if (step.action.id === cp.relatedActionId) {
+            checkpointSteps.set(step.step, cp);
+            break;
+          }
+        }
+      }
+    }
+    lines.push("");
+    lines.push("## Steps");
+    lines.push("");
+    for (const step of summary.steps) {
+      const a = step.action;
+      const el = a.element;
+      const cp = checkpointSteps.get(step.step);
+      if (cp) {
+        lines.push(`### Step ${step.step}: \u26A0\uFE0F CHECKPOINT \u2014 ${cp.hint}`);
+        lines.push(`- **Type**: ${cp.type} (${cp.source})`);
+        lines.push(`- **Hint**: ${cp.hint}`);
+        if (cp.selector) lines.push(`- **Selector**: \`${cp.selector}\``);
+        lines.push(`- **Action needed**: Human intervention required before continuing`);
+      } else {
+        const title = describeActionTitle(a);
+        lines.push(`### Step ${step.step}: ${title}`);
+      }
+      if (el) {
+        const parts = [`\`${el.selector || el.tag}\``];
+        if (el.text) parts.push(`"${el.text.substring(0, 60)}"`);
+        parts.push(`(${el.tag})`);
+        if (el.type) parts.push(`type=${el.type}`);
+        lines.push(`- **Element**: ${parts.join(" ")}`);
+      }
+      if (a.value != null && a.type === "input") {
+        lines.push(`- **Value**: "${a.value.substring(0, 100)}"`);
+      }
+      if (step.network.length > 0) {
+        const netDescs = step.network.map((n) => {
+          let desc = `${n.method} ${n.path}`;
+          if (n.status) desc += ` \u2192 ${n.status}`;
+          if (n.responseSize > 0) desc += ` (${formatBytes(n.responseSize)})`;
+          return desc;
+        });
+        lines.push(`- **Network**: ${netDescs.join(", ")}`);
+        for (const n of step.network) {
+          if (n.requestBody && typeof n.requestBody === "object") {
+            const bodyStr = JSON.stringify(n.requestBody);
+            if (bodyStr.length <= 300) {
+              lines.push(`  - \`${n.method} ${n.path}\` body: \`${bodyStr}\``);
+            } else {
+              lines.push(`  - \`${n.method} ${n.path}\` body: \`${bodyStr.substring(0, 300)}...\` (${bodyStr.length} bytes)`);
+            }
+          }
+        }
+      } else {
+        lines.push("- **Network**: none");
+      }
+      if (step.matchedInputs.length > 0) {
+        for (const m of step.matchedInputs) {
+          lines.push(`- **Input matched**: "${m.inputValue}" \u2192 ${m.paramName} (network #${m.networkId})`);
+        }
+      }
+      for (const ctx of step.contextChanges) {
+        if (ctx.type === "navigate") {
+          lines.push(`- **Navigate**: \u2192 ${ctx.url}`);
+        } else if (ctx.type === "new_tab") {
+          lines.push(`- **New tab**: ${ctx.url}`);
+        }
+      }
+      if (a.clickContext) {
+        if (a.clickContext.appeared?.length > 0) {
+          for (const popup of a.clickContext.appeared) {
+            const roleStr = popup.role ? ` [${popup.role}]` : "";
+            lines.push(`- **Popup**: <${popup.tag}${roleStr}> "${(popup.text || "").substring(0, 60)}"`);
+            if (popup.items?.length > 0) {
+              const itemStrs = popup.items.slice(0, 8).map((i) => {
+                const dis = i.disabled ? " [disabled]" : "";
+                return `"${i.text}"${dis}`;
+              });
+              let itemLine = `  - Items: ${itemStrs.join(", ")}`;
+              if (popup.items.length > 8) itemLine += ` ... +${popup.items.length - 8} more`;
+              lines.push(itemLine);
+            }
+          }
+        }
+        if (a.clickContext.stateChanges?.length > 0) {
+          for (const sc of a.clickContext.stateChanges) {
+            const parts = [];
+            if (sc.ariaExpanded !== void 0) parts.push(`expanded=${sc.ariaExpanded}`);
+            if (sc.disabled) parts.push("disabled");
+            if (sc.ariaSelected !== void 0) parts.push(`selected=${sc.ariaSelected}`);
+            if (sc.dataState) parts.push(`state=${sc.dataState}`);
+            if (parts.length > 0) {
+              lines.push(`- **State**: <${sc.tag}> "${(sc.text || "").substring(0, 30)}" ${parts.join(", ")}`);
+            }
+          }
+        }
+      }
+      lines.push("");
+    }
+    const allNetwork = summary.steps.flatMap((s) => s.network);
+    if (allNetwork.length > 0) {
+      lines.push("## Network Timeline");
+      lines.push("");
+      allNetwork.forEach((n, i) => {
+        let line = `${i + 1}. ${n.method} ${n.path}`;
+        if (n.status) line += ` \u2192 ${n.status}`;
+        if (n.requestBody && typeof n.requestBody === "object") {
+          const bodyStr = JSON.stringify(n.requestBody);
+          if (bodyStr.length <= 150) {
+            line += ` ${bodyStr}`;
+          }
+        }
+        if (n.responseSize > 0) line += ` (${formatBytes(n.responseSize)})`;
+        lines.push(line);
+      });
+      lines.push("");
+    }
+    const orphanCheckpoints = summary.checkpoints.filter(
+      (cp) => cp.relatedActionId == null || !checkpointSteps.has(
+        summary.steps.find((s) => s.action.id === cp.relatedActionId)?.step ?? -1
+      )
+    );
+    if (orphanCheckpoints.length > 0) {
+      lines.push("## Unresolved Checkpoints");
+      lines.push("");
+      for (const cp of orphanCheckpoints) {
+        const src = cp.source === "auto" ? "[auto]" : "[manual]";
+        lines.push(`- ${src} **${cp.type}**: ${cp.hint}`);
+        if (cp.selector) lines.push(`  - Selector: \`${cp.selector}\``);
+      }
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  static readMarkdownSummary(sessionName) {
+    const path = join2(_SessionRecorder.getRecordingsDir(sessionName), "summary.md");
+    try {
+      return readFileSync2(path, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+};
+function describeActionTitle(a) {
+  const el = a.element;
+  const elText = el?.text ? `"${el.text.substring(0, 40)}"` : "";
+  const elTag = el?.tag ? `<${el.tag}>` : "";
+  switch (a.type) {
+    case "click":
+      return `Click ${elText || elTag} button`.replace(/ +/g, " ").trim();
+    case "input":
+      return `Input "${(a.value || "").substring(0, 50)}" in ${elText || elTag || "field"}`.replace(/ +/g, " ").trim();
+    case "change":
+      return `Change ${elText || elTag} to "${(a.value || "").substring(0, 30)}"`;
+    case "keydown":
+      return `Press ${a.key || "key"} on ${elText || elTag || "element"}`;
+    case "submit":
+      return `Submit ${elText || elTag || "form"}`;
+    default:
+      return `${a.type} ${elText || elTag}`.trim() || a.type;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+
+export {
+  SessionRecorder
+};