@refrainai/cli 0.4.1

package/dist/chunk-IGFCYKHC.js

@@ -0,0 +1,1974 @@
+#!/usr/bin/env node
+import {
+  AgentBrowser,
+  DownloadManager,
+  InMemoryDataStore,
+  classifyFailure,
+  createDebugLogger,
+  createReviewUserPrompt,
+  findElementInSnapshot,
+  formatDuration,
+  getAgentInstructions,
+  getInitialUserMessage,
+  getReviewSystemPrompt,
+  noopLogger,
+  parseAllElements,
+  parseAndAppendToMemory,
+  sanitizeBrowserError,
+  sleep
+} from "./chunk-DJVUITRB.js";
+import {
+  filterSnapshot
+} from "./chunk-XMFCXPYU.js";
+import {
+  createSkills,
+  initBuiltinSkills
+} from "./chunk-AG3CFMYU.js";
+import {
+  getLocale,
+  log,
+  promptSelect,
+  promptText,
+  t,
+  tf
+} from "./chunk-7UCVPKD4.js";
+import {
+  getModel,
+  trackedGenerateObject,
+  trackedGenerateText
+} from "./chunk-UGPXCQY3.js";
+import {
+  ParsedRunbookSchema
+} from "./chunk-RT664YIO.js";
+
+// src/runbook-generator/exploration-agent.ts
+import { stepCountIs } from "ai";
+import { z as z2 } from "zod";
+
+// src/runbook-generator/browser-tool.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// src/browser/selector-builder.ts
+var ROLE_TAG_MAP = {
+  textbox: { tagName: "input", inputType: "text" },
+  button: { tagName: "button", role: "button" },
+  link: { tagName: "a", role: "link" },
+  checkbox: { tagName: "input", inputType: "checkbox" },
+  radio: { tagName: "input", inputType: "radio" },
+  combobox: { tagName: "select", role: "combobox" },
+  searchbox: { tagName: "input", inputType: "search" },
+  slider: { tagName: "input", inputType: "range" },
+  spinbutton: { tagName: "input", inputType: "number" },
+  switch: { tagName: "input", inputType: "checkbox", role: "switch" },
+  tab: { tagName: "button", role: "tab" },
+  menuitem: { tagName: "button", role: "menuitem" },
+  option: { tagName: "option", role: "option" },
+  heading: { tagName: "h2", role: "heading" },
+  img: { tagName: "img", role: "img" },
+  navigation: { tagName: "nav", role: "navigation" },
+  listitem: { tagName: "li", role: "listitem" }
+};
+function buildSelector(element) {
+  const mapping = ROLE_TAG_MAP[element.role];
+  const tagName = mapping?.tagName ?? element.role;
+  const selector = { tagName };
+  if (mapping?.role) {
+    selector.role = mapping.role;
+  } else if (element.role !== tagName) {
+    selector.role = element.role;
+  }
+  if (mapping?.inputType) {
+    selector.inputType = mapping.inputType;
+  }
+  if (element.name) {
+    selector.ariaLabel = element.name;
+    if (element.role === "button" || element.role === "link") {
+      selector.innerText = element.name.slice(0, 200);
+    }
+  }
+  if (element.attributes.placeholder) {
+    selector.placeholder = element.attributes.placeholder;
+  }
+  if (element.attributes.name) {
+    selector.name = element.attributes.name;
+  }
+  return selector;
+}
+
+// src/harness/loop-detector.ts
+function stepHash(step) {
+  const urlPath = extractPath(step.url);
+  return `${step.action.action}|${step.action.selector ?? ""}|${urlPath}`;
+}
+function extractPath(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+function detectLoop(recordedSteps, previousNudgeCount, windowSize = 4) {
+  const noLoop = {
+    isLoop: false,
+    loopType: null,
+    nudgeMessage: null,
+    nudgeCount: previousNudgeCount,
+    shouldPromptHuman: false
+  };
+  if (recordedSteps.length < 2) return noLoop;
+  const last = stepHash(recordedSteps[recordedSteps.length - 1]);
+  const secondLast = stepHash(recordedSteps[recordedSteps.length - 2]);
+  if (last === secondLast) {
+    return buildResult("exact_repeat", previousNudgeCount);
+  }
+  if (recordedSteps.length >= windowSize) {
+    const recentSteps = recordedSteps.slice(-windowSize);
+    const dataCollectionActions = /* @__PURE__ */ new Set(["download", "extract", "memory_append", "memory_aggregate", "export"]);
+    const hasDataCollection = recentSteps.some((s) => dataCollectionActions.has(s.action.action));
+    if (!hasDataCollection) {
+      const recentHashes = recentSteps.map(stepHash);
+      const halfLen = Math.floor(windowSize / 2);
+      const firstHalf = recentHashes.slice(0, halfLen).join(",");
+      const secondHalf = recentHashes.slice(halfLen, halfLen * 2).join(",");
+      if (firstHalf === secondHalf) {
+        return buildResult("action_cycle", previousNudgeCount);
+      }
+    }
+  }
+  if (recordedSteps.length >= 4) {
+    const recentUrls = recordedSteps.slice(-4).map((s) => extractPath(s.url));
+    if (recentUrls[0] === recentUrls[2] && recentUrls[1] === recentUrls[3] && recentUrls[0] !== recentUrls[1]) {
+      return buildResult("url_bounce", previousNudgeCount);
+    }
+  }
+  const inputActions = /* @__PURE__ */ new Set(["fill", "type", "select", "check", "uncheck"]);
+  const selectorCounts = /* @__PURE__ */ new Map();
+  for (const step of recordedSteps) {
+    if (!step.success) continue;
+    if (!inputActions.has(step.action.action)) continue;
+    if (!step.action.selector) continue;
+    const key = `${step.action.action}|${step.action.selector}`;
+    const existing = selectorCounts.get(key);
+    if (existing) {
+      existing.count++;
+    } else {
+      selectorCounts.set(key, { count: 1, description: step.action.description });
+    }
+  }
+  const refills = [...selectorCounts.entries()].filter(([, v]) => v.count >= 3).map(([k, v]) => ({ selector: k.split("|")[1], count: v.count, description: v.description }));
+  if (refills.length > 0) {
+    const details = refills.map((r) => `${r.selector} "${r.description}" (${r.count}\u56DE)`).join(", ");
+    return buildRefillResult(details, previousNudgeCount);
+  }
+  return noLoop;
+}
+function buildResult(loopType, previousNudgeCount) {
+  const nudgeCount = previousNudgeCount + 1;
+  const messages = {
+    exact_repeat: "\u540C\u3058\u64CD\u4F5C\u3092\u7E70\u308A\u8FD4\u3057\u3066\u3044\u307E\u3059\u3002\u5225\u306E\u30A2\u30D7\u30ED\u30FC\u30C1\u3092\u8A66\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    action_cycle: "\u64CD\u4F5C\u304C\u30EB\u30FC\u30D7\u3057\u3066\u3044\u307E\u3059\u3002\u7570\u306A\u308B\u6226\u7565\u3092\u691C\u8A0E\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    url_bounce: "\u540C\u3058URL\u9593\u3092\u884C\u304D\u6765\u3057\u3066\u3044\u307E\u3059\u3002\u76EE\u7684\u306E\u30DA\u30FC\u30B8\u306B\u7559\u307E\u3063\u3066\u64CD\u4F5C\u3092\u9032\u3081\u3066\u304F\u3060\u3055\u3044\u3002"
+  };
+  return {
+    isLoop: true,
+    loopType,
+    nudgeMessage: messages[loopType],
+    nudgeCount,
+    // 1回目はナッジのみ、2回目以降は人間に確認
+    shouldPromptHuman: nudgeCount >= 2
+  };
+}
+function buildRefillResult(details, previousNudgeCount) {
+  const nudgeCount = previousNudgeCount + 1;
+  return {
+    isLoop: true,
+    loopType: "selector_refill",
+    nudgeMessage: `\u540C\u3058\u30D5\u30A9\u30FC\u30E0\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u7E70\u308A\u8FD4\u3057\u5165\u529B\u3057\u3066\u3044\u307E\u3059\u3002\u4EE5\u4E0B\u306F\u65E2\u306B\u5165\u529B\u6E08\u307F\u3067\u3059: ${details}\u3002\u5165\u529B\u6E08\u307F\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u30B9\u30AD\u30C3\u30D7\u3057\u3001\u672A\u5165\u529B\u30D5\u30A3\u30FC\u30EB\u30C9\u306B\u9032\u3093\u3067\u304F\u3060\u3055\u3044\u3002`,
+    nudgeCount,
+    shouldPromptHuman: nudgeCount >= 2
+  };
+}
+
+// src/runbook-generator/browser-tool.ts
+var suggestedCaptureSchema = z.object({
+  name: z.string(),
+  strategy: z.enum(["snapshot", "url", "ai", "expression", "evaluate"]),
+  description: z.string().optional(),
+  pattern: z.string().optional(),
+  group: z.number().optional(),
+  prompt: z.string().optional(),
+  expression: z.string().optional()
+});
+var aggregationSchema = z.object({
+  collection: z.string(),
+  field: z.string(),
+  operation: z.enum(["sum", "count", "concat", "min", "max", "avg", "unique_count"]),
+  outputVariable: z.string()
+});
+var actionSchema = z.object({
+  action: z.enum([
+    "click",
+    "fill",
+    "type",
+    "select",
+    "check",
+    "uncheck",
+    "navigate",
+    "wait",
+    "scroll",
+    "extract",
+    "download",
+    "export",
+    "memory_append",
+    "memory_aggregate",
+    "key"
+  ]),
+  selector: z.string().optional(),
+  value: z.string().optional(),
+  description: z.string(),
+  inputCategory: z.enum(["credential", "user_data", "fixed", "navigation"]).optional(),
+  variableName: z.string().optional(),
+  suggestedCaptures: z.array(suggestedCaptureSchema).optional(),
+  /** extract 用: ページ内で実行する JavaScript */
+  script: z.string().optional(),
+  /** extract 用: AI にデータを抽出させるプロンプト */
+  extractPrompt: z.string().optional(),
+  /** memory_append 用: 蓄積先コレクション名 */
+  memoryCollection: z.string().optional(),
+  /** memory_aggregate 用: 集計設定 */
+  aggregation: aggregationSchema.optional(),
+  /** download 用: 保存先パス */
+  downloadPath: z.string().optional(),
+  /** export 用: 出力対象コレクション名 */
+  exportCollection: z.string().optional(),
+  /** export 用: 出力フォーマット */
+  exportFormat: z.enum(["csv", "json"]).optional(),
+  /** export 用: 出力先パス */
+  exportPath: z.string().optional(),
+  /** key 用: 押下するキーボードキー（Playwright 形式、例: "Enter", "Tab"） */
+  keys: z.string().optional()
+});
+var browserInputSchema = z.object({
+  actions: z.array(actionSchema).describe(
+    "\u5B9F\u884C\u3059\u308B\u30D6\u30E9\u30A6\u30B6\u64CD\u4F5C\u306E\u914D\u5217\u3002\u7A7A\u914D\u5217\u306A\u3089\u73FE\u5728\u306E\u30DA\u30FC\u30B8\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306E\u307F\u8FD4\u3059\u3002"
+  )
+});
+function truncateExtractedData(data, maxLength) {
+  try {
+    const parsed = JSON.parse(data);
+    if (Array.isArray(parsed)) {
+      const total = parsed.length;
+      const preview = parsed.slice(0, 3);
+      if (total <= 3) return JSON.stringify(preview);
+      return `${JSON.stringify(preview).slice(0, maxLength)} ... (\u5168${total}\u4EF6)`;
+    }
+  } catch {
+  }
+  if (data.length <= maxLength) return data;
+  return `${data.slice(0, maxLength)}... (${data.length}\u6587\u5B57)`;
+}
+function getActionDelay(action, baseDelay) {
+  switch (action) {
+    case "navigate":
+      return Math.max(baseDelay, 1e3);
+    case "click":
+      return Math.round(baseDelay * 0.6);
+    case "fill":
+    case "type":
+      return Math.round(baseDelay * 0.2);
+    case "select":
+      return Math.round(baseDelay * 0.4);
+    default:
+      return baseDelay;
+  }
+}
+function cancellableSleep(ms, ic) {
+  if (!ic) return sleep(ms);
+  return new Promise((resolve) => {
+    const interval = 50;
+    let elapsed = 0;
+    const timer = setInterval(() => {
+      elapsed += interval;
+      if (elapsed >= ms || ic.isCancelRequested() || ic.isPauseRequested()) {
+        clearInterval(timer);
+        resolve();
+      }
+    }, interval);
+  });
+}
+function createBrowserTool(browser, recordedSteps, config, dataStore, downloadManager) {
+  let ordinal = 0;
+  let nudgeCount = 0;
+  let lastSnapshot = null;
+  let lastExtractedData;
+  const dl = config.debugLogger;
+  const filledFieldsMap = /* @__PURE__ */ new Map();
+  const inputActionTypes = /* @__PURE__ */ new Set(["fill", "type", "select", "check", "uncheck"]);
+  const scratchpadEntries = [];
+  const MAX_SCRATCHPAD = 10;
+  let lastUrl = "";
+  const applySnapshotTransform = async (raw, url, filterOptions) => {
+    if (config.skills) {
+      for (const skill of config.skills) {
+        if (skill.shouldActivate(url)) {
+          try {
+            const result = await skill.transformSnapshot(browser, raw, {
+              url,
+              locale: getLocale()
+            });
+            if (result.extractedData) {
+              lastExtractedData = result.extractedData;
+            }
+            return result;
+          } catch {
+          }
+        }
+      }
+    }
+    const filtered = config.snapshotFilter ? filterSnapshot(raw, filterOptions) : raw;
+    return { snapshot: filtered };
+  };
+  return tool({
+    description: "\u30D6\u30E9\u30A6\u30B6\u64CD\u4F5C\u3092\u5B9F\u884C\u3057\u3001\u64CD\u4F5C\u5F8C\u306E\u30DA\u30FC\u30B8\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u8FD4\u3059\u3002actions\u304C\u7A7A\u306A\u3089\u73FE\u5728\u306E\u30DA\u30FC\u30B8\u72B6\u614B\u306E\u307F\u8FD4\u3059\u3002",
+    inputSchema: browserInputSchema,
+    execute: async (inputData) => {
+      config.onToolCallStart?.(recordedSteps.length);
+      try {
+        const ic = config.interventionController;
+        let interventionNudge;
+        if (ic?.isCancelRequested()) {
+          const snapshot = lastSnapshot ?? await browser.snapshot();
+          const finalSnapshot2 = config.snapshotFilter ? filterSnapshot(snapshot) : snapshot;
+          return {
+            results: [],
+            snapshot: finalSnapshot2,
+            url: await browser.url(),
+            nudgeMessage: "\u30E6\u30FC\u30B6\u30FC\u304C\u63A2\u7D22\u306E\u30AD\u30E3\u30F3\u30BB\u30EB\u3092\u8981\u6C42\u3057\u307E\u3057\u305F\u3002goalAchieved: false \u3067\u6700\u7D42\u5831\u544A\u3092\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+            stepCount: recordedSteps.length
+          };
+        }
+        if (ic?.isPauseRequested()) {
+          const currentUrl2 = await browser.url();
+          const interventionResult = await ic.collectIntervention(
+            recordedSteps.length,
+            currentUrl2
+          );
+          if (interventionResult.action === "abort") {
+            const snapshot = lastSnapshot ?? await browser.snapshot();
+            const finalSnapshot2 = config.snapshotFilter ? filterSnapshot(snapshot) : snapshot;
+            return {
+              results: [],
+              snapshot: finalSnapshot2,
+              url: currentUrl2,
+              nudgeMessage: "\u30E6\u30FC\u30B6\u30FC\u304C\u63A2\u7D22\u306E\u4E2D\u6B62\u3092\u8981\u6C42\u3057\u307E\u3057\u305F\u3002goalAchieved: false \u3067\u6700\u7D42\u5831\u544A\u3092\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+              stepCount: recordedSteps.length
+            };
+          }
+          if (interventionResult.guidanceText) {
+            interventionNudge = tf("browserTool.interventionGuidance", { text: interventionResult.guidanceText });
+          }
+          dl?.log({
+            phase: "generator",
+            event: "user_intervention",
+            step: recordedSteps.length,
+            data: {
+              action: interventionResult.action,
+              guidanceText: interventionResult.guidanceText,
+              url: currentUrl2
+            }
+          });
+        }
+        const results = [];
+        if (inputData.actions.length === 0) {
+          const snapshot = await browser.snapshot();
+          lastSnapshot = snapshot;
+          const currentUrl2 = await browser.url();
+          const transformResult = await applySnapshotTransform(snapshot, currentUrl2);
+          let finalSnapshot2 = transformResult.snapshot;
+          let emptyNudge;
+          const dataCollectionActionSet2 = /* @__PURE__ */ new Set(["download", "extract", "memory_append", "memory_aggregate"]);
+          const hasDataCollectionHistory2 = recordedSteps.some(
+            (s) => s.success && dataCollectionActionSet2.has(s.action.action)
+          );
+          if (hasDataCollectionHistory2) {
+            const pageMatch = snapshot.match(/Page\s+(\d+)\s+(?:of|\/)\s+(\d+)/i);
+            if (pageMatch) {
+              const cp = Number(pageMatch[1]);
+              const tp = Number(pageMatch[2]);
+              if (cp < tp) {
+                const pp = recordedSteps.filter(
+                  (s) => s.success && (s.action.action === "download" || s.action.action === "extract")
+                ).length;
+                emptyNudge = `Pagination progress: Page ${cp} of ${tp} (${pp} pages processed, ${tp - pp} remaining). You MUST continue processing ALL remaining pages \u2014 do NOT stop early.`;
+                const banner = `[PAGINATION INCOMPLETE: ${pp}/${tp} pages processed. ${tp - pp} pages remaining. You MUST continue \u2014 do NOT return goalAchieved yet.]`;
+                finalSnapshot2 = `${banner}
+${finalSnapshot2}`;
+                if (config.paginationTracker) {
+                  config.paginationTracker.currentPage = cp;
+                  config.paginationTracker.totalPages = tp;
+                }
+              }
+            }
+          }
+          dl?.log({
+            phase: "generator",
+            event: "snapshot",
+            step: recordedSteps.length,
+            data: { url: currentUrl2, snapshot, filteredSnapshot: finalSnapshot2 }
+          });
+          const skillExtractedPreview = transformResult.extractedData ? truncateExtractedData(transformResult.extractedData, 500) : void 0;
+          return {
+            results: [],
+            snapshot: finalSnapshot2,
+            url: currentUrl2,
+            nudgeMessage: emptyNudge,
+            stepCount: recordedSteps.length,
+            ...skillExtractedPreview ? { extractedData: skillExtractedPreview } : {}
+          };
+        }
+        const snapshotBefore = lastSnapshot ?? "";
+        for (const action of inputData.actions) {
+          if (ic?.isCancelRequested()) {
+            const snapshot = lastSnapshot ?? await browser.snapshot();
+            const finalSnapshot2 = config.snapshotFilter ? filterSnapshot(snapshot) : snapshot;
+            return {
+              results,
+              snapshot: finalSnapshot2,
+              url: await browser.url(),
+              nudgeMessage: "\u30E6\u30FC\u30B6\u30FC\u304C\u63A2\u7D22\u306E\u30AD\u30E3\u30F3\u30BB\u30EB\u3092\u8981\u6C42\u3057\u307E\u3057\u305F\u3002goalAchieved: false \u3067\u6700\u7D42\u5831\u544A\u3092\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+              stepCount: recordedSteps.length
+            };
+          }
+          if (ic?.isPauseRequested()) {
+            const currentUrl2 = await browser.url();
+            const interventionResult = await ic.collectIntervention(
+              recordedSteps.length,
+              currentUrl2
+            );
+            if (interventionResult.action === "abort") {
+              const snapshot = lastSnapshot ?? await browser.snapshot();
+              const finalSnapshot2 = config.snapshotFilter ? filterSnapshot(snapshot) : snapshot;
+              return {
+                results,
+                snapshot: finalSnapshot2,
+                url: currentUrl2,
+                nudgeMessage: "\u30E6\u30FC\u30B6\u30FC\u304C\u63A2\u7D22\u306E\u4E2D\u6B62\u3092\u8981\u6C42\u3057\u307E\u3057\u305F\u3002goalAchieved: false \u3067\u6700\u7D42\u5831\u544A\u3092\u4F5C\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+                stepCount: recordedSteps.length
+              };
+            }
+            if (interventionResult.guidanceText) {
+              interventionNudge = tf("browserTool.interventionGuidance", { text: interventionResult.guidanceText });
+            }
+            dl?.log({
+              phase: "generator",
+              event: "user_intervention",
+              step: recordedSteps.length,
+              data: {
+                action: interventionResult.action,
+                guidanceText: interventionResult.guidanceText,
+                url: currentUrl2
+              }
+            });
+          }
+          log.step(`${action.description} (${action.action} ${action.selector ?? ""})`);
+          if (action.action === "memory_append" && dataStore) {
+            const actionStart = performance.now();
+            const collection = action.memoryCollection ?? "default";
+            const rawValue = lastExtractedData ?? action.value ?? "";
+            const success = true;
+            const error = void 0;
+            parseAndAppendToMemory(rawValue, {
+              dataStore,
+              debugLogger: dl ?? noopLogger,
+              phase: "generator",
+              step: ordinal,
+              collection
+            });
+            const explorationAction2 = {
+              action: action.action,
+              value: rawValue,
+              description: action.description,
+              memoryCollection: collection
+            };
+            recordedSteps.push({
+              ordinal,
+              action: explorationAction2,
+              snapshotBefore,
+              url: await browser.url(),
+              success,
+              error,
+              durationMs: Math.round(performance.now() - actionStart)
+            });
+            ordinal++;
+            results.push({ description: action.description, success, error });
+            const collectionCount = dataStore.count(collection);
+            if (collectionCount % 50 === 0 || collectionCount <= 5) {
+              addScratchpadEntry(scratchpadEntries, MAX_SCRATCHPAD, `Memory: ${collection} now has ${collectionCount} items`);
+            }
+            continue;
+          }
+          if (action.action === "memory_aggregate" && dataStore && action.aggregation) {
+            const actionStart = performance.now();
+            const agg = action.aggregation;
+            let success = true;
+            let error;
+            let aggregateResult = "";
+            try {
+              aggregateResult = dataStore.aggregate({
+                collection: agg.collection,
+                field: agg.field,
+                operation: agg.operation
+              });
+              log.success(`Memory: ${agg.operation}(${agg.collection}.${agg.field}) = "${aggregateResult}"`);
+              lastExtractedData = aggregateResult;
+            } catch (e) {
+              success = false;
+              error = sanitizeBrowserError(e instanceof Error ? e.message : String(e));
+              log.error(`Memory aggregate failed: ${error}`);
+            }
+            const explorationAction2 = {
+              action: action.action,
+              description: action.description,
+              aggregation: agg
+            };
+            recordedSteps.push({
+              ordinal,
+              action: explorationAction2,
+              snapshotBefore,
+              url: await browser.url(),
+              success,
+              error,
+              durationMs: Math.round(performance.now() - actionStart)
+            });
+            ordinal++;
+            results.push({ description: action.description, success, error });
+            continue;
+          }
+          if (action.action === "extract") {
+            const actionStart = performance.now();
+            let success = true;
+            let error;
+            let extractResult = "";
+            try {
+              if (action.script) {
+                dl?.log({
+                  phase: "generator",
+                  event: "extract",
+                  step: ordinal,
+                  data: { script: action.script.slice(0, 200) }
+                });
+                const result2 = await browser.evaluate(action.script);
+                const isArray = Array.isArray(result2);
+                const stringifyApplied = typeof result2 !== "string" && result2 !== null && result2 !== void 0;
+                extractResult = result2 === null || result2 === void 0 ? "" : typeof result2 === "string" ? result2 : JSON.stringify(result2);
+                dl?.log({
+                  phase: "generator",
+                  event: "extract_result",
+                  step: ordinal,
+                  data: {
+                    resultType: result2 === null ? "null" : typeof result2,
+                    isArray,
+                    arrayLength: isArray ? result2.length : void 0,
+                    resultPreview: extractResult.slice(0, 200),
+                    storedLength: extractResult.length,
+                    stringifyApplied
+                  }
+                });
+              } else if (action.extractPrompt) {
+                dl?.log({
+                  phase: "generator",
+                  event: "extract",
+                  step: ordinal,
+                  data: { extractPrompt: action.extractPrompt.slice(0, 200) }
+                });
+                const snapshot = await browser.snapshot();
+                const { getModel: getModel2, trackedGenerateObject: trackedGenerateObject2 } = await import("./ai-model-FM6GWCID.js");
+                const extractSchema = z.object({ data: z.string() });
+                const aiResult = await trackedGenerateObject2("extraction", {
+                  model: getModel2("extraction"),
+                  prompt: `${action.extractPrompt}
+
+\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8:
+${snapshot}`,
+                  schema: extractSchema,
+                  temperature: 0
+                });
+                extractResult = aiResult.object?.data ?? "";
+                dl?.log({
+                  phase: "generator",
+                  event: "extract_result",
+                  step: ordinal,
+                  data: {
+                    resultType: "string (AI)",
+                    resultPreview: extractResult.slice(0, 200),
+                    storedLength: extractResult.length
+                  }
+                });
+              }
+              lastExtractedData = extractResult;
+              log.success(`Extracted: ${extractResult.slice(0, 100)}${extractResult.length > 100 ? "..." : ""}`);
+              const extractLen = extractResult.length;
+              addScratchpadEntry(scratchpadEntries, MAX_SCRATCHPAD, `Extracted ${extractLen > 200 ? `${extractLen} chars` : "data"} via ${action.script ? "script" : "AI prompt"}`);
+            } catch (e) {
+              success = false;
+              error = sanitizeBrowserError(e instanceof Error ? e.message : String(e));
+              log.error(`Extract failed: ${error}`);
+            }
+            const explorationAction2 = {
+              action: action.action,
+              description: action.description,
+              script: action.script,
+              extractPrompt: action.extractPrompt
+            };
+            recordedSteps.push({
+              ordinal,
+              action: explorationAction2,
+              snapshotBefore,
+              url: await browser.url(),
+              success,
+              error,
+              durationMs: Math.round(performance.now() - actionStart)
+            });
+            ordinal++;
+            results.push({ description: action.description, success, error });
+            continue;
+          }
+          if (action.action === "download") {
+            const actionStart = performance.now();
+            let success = true;
+            let error;
+            const downloadPath = action.downloadPath ?? `/tmp/download-${Date.now()}.bin`;
+            try {
+              if (action.selector) {
+                await browser.download(action.selector, downloadPath);
+              } else {
+                await browser.waitForDownload(downloadPath);
+              }
+              log.success(`Downloaded: ${downloadPath}`);
+              if (downloadManager) {
+                downloadManager.addDownload({
+                  path: downloadPath,
+                  filename: downloadPath.split("/").pop() ?? "unknown",
+                  stepOrdinal: ordinal,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+            } catch (e) {
+              success = false;
+              error = sanitizeBrowserError(e instanceof Error ? e.message : String(e));
+              log.error(`Download failed: ${error}`);
+            }
+            const explorationAction2 = {
+              action: action.action,
+              selector: action.selector,
+              description: action.description,
+              downloadPath
+            };
+            recordedSteps.push({
+              ordinal,
+              action: explorationAction2,
+              snapshotBefore,
+              url: await browser.url(),
+              success,
+              error,
+              durationMs: Math.round(performance.now() - actionStart)
+            });
+            ordinal++;
+            results.push({ description: action.description, success, error });
+            continue;
+          }
+          if (action.action === "export" && dataStore) {
+            const actionStart = performance.now();
+            const collection = action.exportCollection ?? "default";
+            const format = action.exportFormat ?? "csv";
+            const exportPath = action.exportPath ?? `/tmp/${collection}.${format}`;
+            let success = true;
+            let error;
+            try {
+              const exportItems = dataStore.getAll(collection);
+              const sampleKeys = exportItems.length > 0 ? JSON.stringify(Object.keys(exportItems[0])) : "N/A";
+              dl?.log({
+                phase: "generator",
+                event: "export",
+                step: ordinal,
+                data: {
+                  collection,
+                  itemCount: exportItems.length,
+                  format,
+                  path: exportPath,
+                  sampleKeys
+                }
+              });
+              await dataStore.writeToFile(collection, exportPath, format);
+              log.success(`Exported: ${collection} \u2192 ${exportPath} (${format})`);
+              lastExtractedData = exportPath;
+              if (downloadManager) {
+                downloadManager.addDownload({
+                  path: exportPath,
+                  filename: exportPath.split("/").pop() ?? "unknown",
+                  stepOrdinal: ordinal,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+            } catch (e) {
+              success = false;
+              error = sanitizeBrowserError(e instanceof Error ? e.message : String(e));
+              log.error(`Export failed: ${error}`);
+            }
+            const explorationAction2 = {
+              action: action.action,
+              description: action.description,
+              exportCollection: collection,
+              exportFormat: format,
+              exportPath
+            };
+            recordedSteps.push({
+              ordinal,
+              action: explorationAction2,
+              snapshotBefore,
+              url: await browser.url(),
+              success,
+              error,
+              durationMs: Math.round(performance.now() - actionStart)
+            });
+            ordinal++;
+            results.push({ description: action.description, success, error });
+            continue;
+          }
+          if (action.action === "key") {
+            const actionStart = performance.now();
+            const keys = action.keys ?? action.value ?? "";
+            let success = true;
+            let error;
+            try {
+              await browser.pressKeys(keys);
+              log.success(`Key: ${keys}`);
+            } catch (e) {
+              success = false;
+              error = sanitizeBrowserError(e instanceof Error ? e.message : String(e));
+              log.error(`Key failed: ${error}`);
+            }
+            const explorationAction2 = {
+              action: "key",
+              description: action.description,
+              keys
+            };
+            recordedSteps.push({
+              ordinal,
+              action: explorationAction2,
+              snapshotBefore,
+              url: await browser.url(),
+              success,
+              error,
+              durationMs: Math.round(performance.now() - actionStart)
+            });
+            ordinal++;
+            results.push({ description: action.description, success, error });
+            continue;
+          }
+          const explorationAction = {
+            action: action.action,
+            selector: action.selector,
+            value: action.value,
+            description: action.description,
+            inputCategory: action.inputCategory,
+            variableName: action.variableName,
+            suggestedCaptures: action.suggestedCaptures
+          };
+          const navigatingActions = /* @__PURE__ */ new Set(["click", "navigate"]);
+          const mayNavigate = navigatingActions.has(action.action);
+          const urlBeforeAction = mayNavigate ? await browser.url() : "";
+          const pageCountBefore = mayNavigate ? await browser.pageCount() : 0;
+          const result = await browser.executeStep(explorationAction);
+          if (mayNavigate) {
+            await browser.waitForPossibleNavigation(
+              urlBeforeAction,
+              pageCountBefore
+            );
+          }
+          const stepUrl = await browser.url();
+          const recorded = {
+            ordinal,
+            action: explorationAction,
+            snapshotBefore,
+            url: stepUrl,
+            success: result.success,
+            error: result.error,
+            durationMs: result.durationMs,
+            failureCategory: result.success ? void 0 : classifyFailure({
+              error: result.error ?? "unknown error",
+              selectorResolved: !!action.selector,
+              actionExecuted: true
+            })
+          };
+          recordedSteps.push(recorded);
+          ordinal++;
+          results.push({
+            description: action.description,
+            success: result.success,
+            error: result.error
+          });
+          dl?.log({
+            phase: "generator",
+            event: "action",
+            step: ordinal - 1,
+            data: {
+              action: action.action,
+              selector: action.selector,
+              value: action.value,
+              description: action.description,
+              result: {
+                success: result.success,
+                error: result.error,
+                durationMs: result.durationMs
+              },
+              url: stepUrl,
+              failureCategory: recorded.failureCategory
+            }
+          });
+          if (result.success) {
+            log.success(`OK (${result.durationMs}ms)`);
+            if (inputActionTypes.has(action.action) && action.selector) {
+              filledFieldsMap.set(action.selector, action.description);
+            }
+            if (mayNavigate && stepUrl !== urlBeforeAction) {
+              addScratchpadEntry(scratchpadEntries, MAX_SCRATCHPAD, `Navigated ${shortenUrl(urlBeforeAction)} \u2192 ${shortenUrl(stepUrl)}`);
+              lastUrl = stepUrl;
+              addScratchpadEntry(scratchpadEntries, MAX_SCRATCHPAD, `GOAL CHECK: Verify ALL parts of the goal are completed before declaring goalAchieved. Your claim will be independently verified.`);
+            }
+            if (ordinal > 0 && ordinal % 5 === 0) {
+              addScratchpadEntry(scratchpadEntries, MAX_SCRATCHPAD, `REMINDER (step ${ordinal}): Before declaring goalAchieved, re-read the original goal and confirm ALL sub-tasks are done. Include evidence in your summary.`);
+            }
+          } else {
+            log.error(`FAILED: ${result.error}`);
+            addScratchpadEntry(scratchpadEntries, MAX_SCRATCHPAD, `${action.action} ${action.selector ?? ""} failed: ${(result.error ?? "unknown").slice(0, 60)}`);
+          }
+          await cancellableSleep(getActionDelay(action.action, config.stepDelay), ic);
+        }
+        let navigateNudge;
+        if (inputData.actions.some((a) => a.action === "navigate") && lastSnapshot) {
+          const linkCount = parseAllElements(lastSnapshot).filter((e) => e.role === "link").length;
+          if (linkCount > 0) {
+            navigateNudge = `\u6CE8\u610F: \u30DA\u30FC\u30B8\u4E0A\u306B ${linkCount} \u500B\u306E\u30EA\u30F3\u30AF\u304C\u3042\u308A\u307E\u3059\u3002navigate \u3067URL\u3092\u7D44\u307F\u7ACB\u3066\u308B\u306E\u3067\u306F\u306A\u304F\u3001\u30DA\u30FC\u30B8\u4E0A\u306E\u30EA\u30F3\u30AF\u3092 click \u3067\u8FBF\u3063\u3066\u304F\u3060\u3055\u3044\u3002`;
+          }
+        }
+        let nudgeMessage = navigateNudge;
+        if (recordedSteps.length >= 2) {
+          const loopResult = detectLoop(recordedSteps, nudgeCount);
+          if (loopResult.isLoop) {
+            nudgeCount = loopResult.nudgeCount;
+            const loopNudge = loopResult.nudgeMessage ?? void 0;
+            nudgeMessage = nudgeMessage && loopNudge ? `${nudgeMessage}
+${loopNudge}` : loopNudge ?? nudgeMessage;
+            log.warn(`Loop detected: ${loopResult.loopType}`);
+            dl?.log({
+              phase: "generator",
+              event: "loop_detection",
+              step: recordedSteps.length - 1,
+              data: loopResult
+            });
+          }
+        }
+        const postSnapshot = await browser.snapshot();
+        const currentUrl = await browser.url();
+        const textOnlyActions = /* @__PURE__ */ new Set(["fill", "type"]);
+        const allTextOnly = inputData.actions.length > 0 && inputData.actions.every((a) => textOnlyActions.has(a.action)) && results.every((r) => r.success);
+        let finalSnapshot;
+        if (allTextOnly && lastSnapshot) {
+          const oldSig = extractStructuralSignature(lastSnapshot);
+          const newSig = extractStructuralSignature(postSnapshot);
+          if (oldSig === newSig) {
+            finalSnapshot = buildDiffSnapshot(postSnapshot, filledFieldsMap);
+            dl?.log({
+              phase: "generator",
+              event: "snapshot_diff",
+              step: recordedSteps.length - 1,
+              data: { url: currentUrl, reason: "structure_unchanged", elementCount: newSig.split("\n").length }
+            });
+          } else {
+            const filledSelectors = filledFieldsMap.size > 0 ? new Set(filledFieldsMap.keys()) : void 0;
+            const tr = await applySnapshotTransform(postSnapshot, currentUrl, { filledSelectors });
+            finalSnapshot = tr.snapshot;
+            dl?.log({
+              phase: "generator",
+              event: "snapshot",
+              step: recordedSteps.length - 1,
+              data: { url: currentUrl, snapshot: postSnapshot, filteredSnapshot: finalSnapshot }
+            });
+          }
+        } else {
+          const filledSelectors = filledFieldsMap.size > 0 ? new Set(filledFieldsMap.keys()) : void 0;
+          const tr = await applySnapshotTransform(postSnapshot, currentUrl, { filledSelectors });
+          finalSnapshot = tr.snapshot;
+          dl?.log({
+            phase: "generator",
+            event: "snapshot",
+            step: recordedSteps.length - 1,
+            data: { url: currentUrl, snapshot: postSnapshot, filteredSnapshot: finalSnapshot }
+          });
+        }
+        lastSnapshot = postSnapshot;
+        if (interventionNudge) {
+          nudgeMessage = nudgeMessage ? `${interventionNudge}
+${nudgeMessage}` : interventionNudge;
+        }
+        const memoryStatus = dataStore ? Object.fromEntries(
+          dataStore.listCollections().map((c) => [c, dataStore.count(c)])
+        ) : void 0;
+        const hasExtractAction = inputData.actions.some(
+          (a) => a.action === "extract" || a.action === "memory_aggregate"
+        );
+        const skillProvidedData = config.skills?.some((s) => s.shouldActivate(currentUrl)) && lastExtractedData;
+        const extractedDataPreview = (hasExtractAction || skillProvidedData) && lastExtractedData ? truncateExtractedData(lastExtractedData, 500) : void 0;
+        const keepRecent = 5;
+        if (recordedSteps.length > keepRecent) {
+          const stepToPrune = recordedSteps[recordedSteps.length - keepRecent - 1];
+          if (stepToPrune.snapshotBefore && stepToPrune.action.selector) {
+            const ref = stepToPrune.action.selector.replace("@", "");
+            const element = findElementInSnapshot(stepToPrune.snapshotBefore, ref);
+            if (element) {
+              stepToPrune.resolvedElement = buildSelector(element);
+            }
+          }
+          stepToPrune.snapshotBefore = "";
+        }
+        const filledFieldsSummary = filledFieldsMap.size > 0 ? [...filledFieldsMap.entries()].map(([sel, desc]) => `${sel}: ${desc}`).join(", ") : void 0;
+        let paginationCurrentPage = 0;
+        let paginationTotalPages = 0;
+        let paginationPagesProcessed = 0;
+        const dataCollectionActionSet = /* @__PURE__ */ new Set(["download", "extract", "memory_append", "memory_aggregate"]);
+        const hasDataCollectionHistory = recordedSteps.some(
+          (s) => s.success && dataCollectionActionSet.has(s.action.action)
+        );
+        if (hasDataCollectionHistory) {
+          const pageMatch = postSnapshot.match(/Page\s+(\d+)\s+(?:of|\/)\s+(\d+)/i);
+          if (pageMatch) {
+            paginationCurrentPage = Number(pageMatch[1]);
+            paginationTotalPages = Number(pageMatch[2]);
+            if (paginationCurrentPage < paginationTotalPages) {
+              paginationPagesProcessed = recordedSteps.filter(
+                (s) => s.success && (s.action.action === "download" || s.action.action === "extract")
+              ).length;
+              const paginationNudge = `Pagination progress: Page ${paginationCurrentPage} of ${paginationTotalPages} (${paginationPagesProcessed} pages processed, ${paginationTotalPages - paginationPagesProcessed} remaining). You MUST continue processing ALL remaining pages \u2014 do NOT stop early.`;
+              nudgeMessage = nudgeMessage ? `${nudgeMessage}
+${paginationNudge}` : paginationNudge;
+              if (config.paginationTracker) {
+                config.paginationTracker.currentPage = paginationCurrentPage;
+                config.paginationTracker.totalPages = paginationTotalPages;
+              }
+            }
+          }
+        }
+        if (filledFieldsMap.size >= 3) {
+          const formRoles = /* @__PURE__ */ new Set(["textbox", "combobox", "checkbox", "spinbutton"]);
+          const filledRefs = new Set(
+            [...filledFieldsMap.keys()].map((s) => s.replace("@", ""))
+          );
+          const allElements = parseAllElements(postSnapshot);
+          const remainingFormElements = allElements.filter(
+            (e) => formRoles.has(e.role) && !filledRefs.has(e.ref)
+          );
+          if (remainingFormElements.length > 0) {
+            const names = remainingFormElements.map((e) => e.name ? `"${e.name}"` : `@${e.ref}`).join(", ");
+            const formHint = `Note: ${remainingFormElements.length} form fields not yet filled: ${names}. Fill all remaining fields before submitting.`;
+            nudgeMessage = nudgeMessage ? `${nudgeMessage}
+${formHint}` : formHint;
+          }
+        }
+        if (paginationCurrentPage > 0 && paginationCurrentPage < paginationTotalPages) {
+          const banner = `[PAGINATION INCOMPLETE: ${paginationPagesProcessed}/${paginationTotalPages} pages processed. ${paginationTotalPages - paginationPagesProcessed} pages remaining. You MUST continue \u2014 do NOT return goalAchieved yet.]`;
+          finalSnapshot = `${banner}
+${finalSnapshot}`;
+        }
+        const scratchpad = scratchpadEntries.length > 0 ? scratchpadEntries.join("\n") : void 0;
+        return {
+          results,
+          snapshot: finalSnapshot,
+          url: currentUrl,
+          nudgeMessage,
+          stepCount: recordedSteps.length,
+          ...memoryStatus && Object.keys(memoryStatus).length > 0 ? { memoryStatus } : {},
+          ...extractedDataPreview ? { extractedData: extractedDataPreview } : {},
+          ...filledFieldsSummary ? { filledFields: filledFieldsSummary } : {},
+          ...scratchpad ? { scratchpad } : {}
+        };
+      } finally {
+        config.onToolCallEnd?.();
+      }
+    }
+  });
+}
+function addScratchpadEntry(entries, max, entry) {
+  entries.push(entry);
+  if (entries.length > max) {
+    entries.shift();
+  }
+}
+function shortenUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname + (parsed.search ? parsed.search.slice(0, 30) : "");
+  } catch {
+    return url.slice(0, 50);
+  }
+}
+function extractStructuralSignature(snapshot) {
+  return snapshot.split("\n").map((line) => {
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trimStart().replace(/^-\s+/, "");
+    const roleMatch = trimmed.match(/^(\S+)/);
+    const refMatch = line.match(/\[ref=(e\d+)\]/);
+    return `${indent}:${roleMatch?.[1] ?? ""}:${refMatch?.[1] ?? ""}`;
+  }).join("\n");
+}
+function buildDiffSnapshot(snapshot, filledFieldsMap) {
+  const elements = parseAllElements(snapshot);
+  const filledRefs = new Set(
+    [...filledFieldsMap.keys()].map((sel) => sel.replace("@", ""))
+  );
+  const unfilled = [];
+  const filled = [];
+  for (const el of elements) {
+    const label = `@${el.ref} ${el.role}${el.name ? ` "${el.name}"` : ""}`;
+    if (filledRefs.has(el.ref)) {
+      filled.push(label);
+    } else {
+      unfilled.push(label);
+    }
+  }
+  const lines = [
+    `[Structure unchanged after text input. ${elements.length} interactive elements, all refs valid.]`
+  ];
+  if (unfilled.length > 0) {
+    lines.push(`Unfilled: ${unfilled.join(", ")}`);
+  }
+  if (filled.length > 0) {
+    lines.push(`Filled (${filled.length}): ${filled.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+// src/runbook-generator/exploration-agent.ts
+function routeExplorationModel(stepNumber, messages, recordedSteps) {
+  if (stepNumber <= 2) {
+    return { purpose: "exploration", reason: "initial_observation" };
+  }
+  const toolIndices = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "tool") toolIndices.push(i);
+  }
+  if (toolIndices.length > 0) {
+    const lastToolMsg = messages[toolIndices[toolIndices.length - 1]];
+    const lastVal = extractToolOutputValue(lastToolMsg);
+    if (lastVal) {
+      const results = lastVal.results;
+      if (results?.some((r) => !r.success)) {
+        return { purpose: "exploration", reason: "previous_step_failed" };
+      }
+      if (lastVal.nudgeMessage) {
+        return { purpose: "exploration", reason: "nudge_active" };
+      }
+    }
+  }
+  if (recordedSteps.length >= 2) {
+    const last = recordedSteps[recordedSteps.length - 1];
+    const prev = recordedSteps[recordedSteps.length - 2];
+    if (last.url !== prev.url) {
+      return { purpose: "exploration", reason: "page_changed" };
+    }
+  }
+  if (toolIndices.length > 0) {
+    const phase = detectExplorationPhase(messages, toolIndices);
+    if (phase === "form_filling") {
+      return { purpose: "exploration-light", reason: "routine_form_fill" };
+    }
+    if (phase === "data_collection") {
+      return { purpose: "exploration-light", reason: "routine_data_collection" };
+    }
+  }
+  if (recordedSteps.length >= 3) {
+    const recent = recordedSteps.slice(-3);
+    const allSucceeded = recent.every((s) => s.success);
+    const sameUrl = recent.every((s) => s.url === recent[0].url);
+    if (allSucceeded && sameUrl) {
+      return { purpose: "exploration-light", reason: "stable_operation" };
+    }
+  }
+  return { purpose: "exploration", reason: "default" };
+}
+async function exploreWithAI(browser, recordedSteps, config, dataStore, downloadManager) {
+  const paginationTracker = { currentPage: 0, totalPages: 0 };
+  const toolConfig = {
+    stepDelay: config.stepDelay,
+    screenshotDir: config.screenshotDir,
+    snapshotFilter: config.snapshotFilter,
+    debugLogger: config.debugLogger,
+    interventionController: config.interventionController,
+    paginationTracker,
+    onToolCallStart: config.onToolCallStart,
+    onToolCallEnd: config.onToolCallEnd,
+    skills: config.skills
+  };
+  const browserTool = createBrowserTool(browser, recordedSteps, toolConfig, dataStore, downloadManager);
+  const totalMaxSteps = config.maxIterations * 3;
+  const promptLocale = config.locale ?? getLocale();
+  let systemContent = getAgentInstructions(
+    config.goal,
+    config.contextMarkdown,
+    config.secrets,
+    promptLocale
+  );
+  if (config.skills && config.skills.length > 0) {
+    const currentUrl = await browser.url();
+    for (const skill of config.skills) {
+      const augmentation = skill.getPromptAugmentation({
+        url: currentUrl,
+        locale: promptLocale
+      });
+      if (augmentation) {
+        systemContent += augmentation;
+      }
+    }
+  }
+  const systemMessage = {
+    role: "system",
+    content: systemContent,
+    providerOptions: {
+      anthropic: { cacheControl: { type: "ephemeral" } }
+    }
+  };
+  const STALL_THRESHOLD = 6;
+  let lastProgressPage = 0;
+  let stepsWithoutProgress = 0;
+  const prepareStep = ({ messages, stepNumber }) => {
+    if (stepNumber <= 1) return void 0;
+    const pruned = pruneOldToolResults(messages, config.historyWindow);
+    if (paginationTracker.currentPage > lastProgressPage) {
+      lastProgressPage = paginationTracker.currentPage;
+      stepsWithoutProgress = 0;
+    } else {
+      stepsWithoutProgress++;
+    }
+    const paginationInProgress = paginationTracker.totalPages > 0 && paginationTracker.currentPage < paginationTracker.totalPages;
+    const notStalled = stepsWithoutProgress < STALL_THRESHOLD;
+    if (config.enableMultiModel) {
+      const decision = routeExplorationModel(stepNumber, messages, recordedSteps);
+      const model = config.aiProvider ? config.aiProvider.getModel(decision.purpose) : getModel(decision.purpose);
+      if (paginationInProgress && notStalled) {
+        return { messages: pruned, toolChoice: "required", model };
+      }
+      return { messages: pruned, model };
+    }
+    if (paginationInProgress && notStalled) {
+      return { messages: pruned, toolChoice: "required" };
+    }
+    return { messages: pruned };
+  };
+  const explorationModel = config.aiProvider ? config.aiProvider.getModel("exploration") : getModel("exploration");
+  const result = await trackedGenerateText("exploration", {
+    model: explorationModel,
+    messages: [
+      systemMessage,
+      { role: "user", content: getInitialUserMessage(promptLocale) }
+    ],
+    tools: { browser: browserTool },
+    // output: Output.object 削除 — responseFormat の干渉を排除
+    stopWhen: [stepCountIs(totalMaxSteps + 1)],
+    prepareStep
+  });
+  const goalResult = parseAgentResultFallback(result.text);
+  const usageInfo = {
+    promptTokens: result.usage.inputTokens ?? 0,
+    completionTokens: result.usage.outputTokens ?? 0,
+    totalTokens: (result.usage.inputTokens ?? 0) + (result.usage.outputTokens ?? 0)
+  };
+  if (goalResult.goalAchieved) {
+    const verification = await verifyGoalAchievement(
+      browser,
+      config.goal,
+      goalResult.summary,
+      recordedSteps,
+      config.aiProvider
+    );
+    if (!verification.achieved) {
+      goalResult.goalAchieved = false;
+      goalResult.summary = `[Verification failed: ${verification.reason}] ${goalResult.summary}`;
+    }
+  } else if (!goalResult.parsed) {
+    const verification = await verifyGoalAchievement(
+      browser,
+      config.goal,
+      goalResult.summary,
+      recordedSteps,
+      config.aiProvider
+    );
+    if (verification.achieved) {
+      goalResult.goalAchieved = true;
+      goalResult.summary = verification.reason;
+    }
+  }
+  return {
+    goalResult,
+    totalTokens: usageInfo
+  };
+}
+function pruneOldToolResults(messages, historyWindow = 10) {
+  let toolIndices = [];
+  for (let i = 0; i < messages.length; i++) {
+    if (messages[i].role === "tool") toolIndices.push(i);
+  }
+  if (toolIndices.length <= 2) return messages;
+  const phase = detectExplorationPhase(messages, toolIndices);
+  const rawSize = phase === "form_filling" ? 4 : 2;
+  const compactSize = phase === "form_filling" ? 4 : 2;
+  if (toolIndices.length > historyWindow) {
+    const cutoffIndex = toolIndices[toolIndices.length - historyWindow];
+    let startIndex = cutoffIndex;
+    if (startIndex > 0 && messages[startIndex - 1].role === "assistant") {
+      startIndex = startIndex - 1;
+    }
+    const preamble = messages.filter(
+      (m, i) => i < startIndex && (m.role === "system" || m.role === "user" && i < 3)
+    );
+    const droppedCount = toolIndices.length - historyWindow;
+    const summaryMsg = {
+      role: "user",
+      content: `[${droppedCount} earlier tool turns omitted for context efficiency]`
+    };
+    messages = [...preamble, summaryMsg, ...messages.slice(startIndex)];
+    toolIndices = [];
+    for (let i = 0; i < messages.length; i++) {
+      if (messages[i].role === "tool") toolIndices.push(i);
+    }
+    if (toolIndices.length <= 2) return messages;
+  }
+  const estimatedChars = estimateMessageChars(messages);
+  const HIGH_PRESSURE_CHARS = 4e5;
+  const isHighPressure = estimatedChars > HIGH_PRESSURE_CHARS;
+  const effectiveRawSize = isHighPressure ? Math.max(1, rawSize - 1) : rawSize;
+  const effectiveCompactSize = isHighPressure ? Math.max(1, compactSize - 1) : compactSize;
+  const recentThreshold = toolIndices[Math.max(0, toolIndices.length - effectiveRawSize)];
+  const compactThreshold = toolIndices.length > effectiveRawSize + effectiveCompactSize ? toolIndices[toolIndices.length - effectiveRawSize - effectiveCompactSize] : 0;
+  return messages.map((msg, i) => {
+    if (msg.role !== "tool") return msg;
+    if (i >= recentThreshold) return msg;
+    if (i >= compactThreshold) return compactToolResult(msg);
+    return summarizeToolResult(msg);
+  });
+}
+function detectExplorationPhase(messages, toolIndices) {
+  const recentTools = toolIndices.slice(-3);
+  let fillCount = 0;
+  let extractCount = 0;
+  for (const idx of recentTools) {
+    const msg = messages[idx];
+    const val = extractToolOutputValue(msg);
+    if (val) {
+      if ("filledFields" in val && val.filledFields) fillCount++;
+      if ("extractedData" in val && val.extractedData) extractCount++;
+      if ("memoryStatus" in val && val.memoryStatus) extractCount++;
+    }
+  }
+  if (fillCount >= 2) return "form_filling";
+  if (extractCount >= 2) return "data_collection";
+  return "exploring";
+}
+function extractToolOutputValue(msg) {
+  if (!Array.isArray(msg.content)) return null;
+  const parts = msg.content;
+  for (const part of parts) {
+    if (part.type !== "tool-result") continue;
+    const output = part.output;
+    if (output?.type === "json" && typeof output.value === "object" && output.value !== null) {
+      return output.value;
+    }
+  }
+  return null;
+}
+function estimateMessageChars(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    if (typeof msg.content === "string") {
+      total += msg.content.length;
+    } else if (Array.isArray(msg.content)) {
+      total += JSON.stringify(msg.content).length;
+    }
+  }
+  return total;
+}
+function mapToolResultValue(msg, transform) {
+  if (!Array.isArray(msg.content)) return msg;
+  const parts = msg.content;
+  const prunedContent = parts.map((part) => {
+    if (part.type !== "tool-result") return part;
+    const output = part.output;
+    if (typeof output !== "object" || output === null) return part;
+    const out = output;
+    if (out.type === "json" && typeof out.value === "object" && out.value !== null) {
+      const val = { ...out.value };
+      const transformed = transform(val);
+      return { ...part, output: { ...out, value: transformed } };
+    }
+    return part;
+  });
+  return { ...msg, content: prunedContent };
+}
+function compactToolResult(msg) {
+  return mapToolResultValue(msg, (val) => {
+    if ("snapshot" in val) {
+      val.snapshot = "[\u7701\u7565]";
+    }
+    if ("extractedData" in val) {
+      delete val.extractedData;
+    }
+    return val;
+  });
+}
+function summarizeToolResult(msg) {
+  return mapToolResultValue(msg, (val) => {
+    if ("snapshot" in val) {
+      delete val.snapshot;
+    }
+    if ("extractedData" in val) {
+      delete val.extractedData;
+    }
+    if ("results" in val && Array.isArray(val.results)) {
+      const results = val.results;
+      const failures = results.filter((r) => !r.success);
+      const successes = results.filter((r) => r.success);
+      const compressed = [...failures];
+      if (successes.length > 0) {
+        compressed.push({ description: `${successes.length}\u4EF6\u6210\u529F`, success: true });
+      }
+      val.results = compressed;
+    }
+    return val;
+  });
+}
+var agentResultSchema = z2.object({
+  goalAchieved: z2.boolean(),
+  summary: z2.string().default("")
+});
+var goalVerificationSchema = z2.object({
+  achieved: z2.boolean(),
+  reason: z2.string()
+});
+var SIDE_EFFECT_ACTIONS = /* @__PURE__ */ new Set(["download", "export", "memory_append", "memory_aggregate", "extract"]);
+function buildExecutionEvidence(recordedSteps) {
+  const totalSteps = recordedSteps.length;
+  const succeededSteps = recordedSteps.filter((s) => s.success).length;
+  const lines = [];
+  lines.push(`Completed Actions (${totalSteps} steps, ${succeededSteps} succeeded):`);
+  for (const step of recordedSteps) {
+    const status = step.success ? "success" : "FAILED";
+    const errorSuffix = step.error ? ` \u2014 ${step.error}` : "";
+    lines.push(`- Step ${step.ordinal}: ${step.action.action} \u2014 ${step.action.description} (${status}${errorSuffix})`);
+  }
+  const sideEffectCounts = /* @__PURE__ */ new Map();
+  for (const step of recordedSteps) {
+    if (step.success && SIDE_EFFECT_ACTIONS.has(step.action.action)) {
+      sideEffectCounts.set(step.action.action, (sideEffectCounts.get(step.action.action) ?? 0) + 1);
+    }
+  }
+  if (sideEffectCounts.size > 0) {
+    const parts = Array.from(sideEffectCounts.entries()).map(
+      ([action, count]) => `${count} ${action}`
+    );
+    lines.push(`
+Side effects (not visible in page snapshot): ${parts.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+async function verifyGoalAchievement(browser, goal, declaredSummary, recordedSteps, aiProvider) {
+  try {
+    const snapshot = await browser.snapshot();
+    const currentUrl = await browser.url();
+    const truncatedSnapshot = snapshot.length > 8e3 ? `${snapshot.slice(0, 8e3)}
+[... truncated]` : snapshot;
+    const executionEvidence = buildExecutionEvidence(recordedSteps);
+    const prompt = `You are an independent verifier. Your task is to check whether a browser automation goal has ACTUALLY been achieved based on the current page state and execution evidence.
+
+## Goal
+${goal}
+
+## Current State
+URL: ${currentUrl}
+Page snapshot (accessibility tree):
+${truncatedSnapshot}
+
+## Agent's Claim
+"${declaredSummary}"
+
+## Execution Evidence
+${executionEvidence}
+
+## Verification Checklist
+Check ALL of the following:
+1. Does the current page clearly show the expected outcome of the goal?
+2. Are there any error messages, validation warnings, or "try again" prompts?
+3. For login/auth goals: Is a login form still visible? Are there auth error messages?
+4. For form submission goals: Is there a clear success confirmation? Or is the form still displayed?
+5. For navigation goals: Does the URL and page content match the intended destination?
+6. For compound goals (A then B then C): Can you see evidence that ALL parts were completed, not just the first part?
+7. For goals involving file downloads, data export, or memory operations: These side effects are confirmed by the Execution Evidence above, NOT by the page snapshot. If the execution log shows all download/export/aggregate steps succeeded, consider this as valid evidence of completion.
+
+Be CONSERVATIVE: if the page state is ambiguous or doesn't clearly confirm ALL parts of the goal were achieved, set achieved to false.
+Do NOT trust the agent's claim \u2014 verify independently from the page state and execution evidence.`;
+    const verificationModel = aiProvider ? aiProvider.getModel("exploration") : getModel("exploration");
+    const verificationResult = await trackedGenerateObject("exploration", {
+      model: verificationModel,
+      prompt,
+      schema: goalVerificationSchema,
+      temperature: 0
+    });
+    return verificationResult.object ?? { achieved: true, reason: "verification_returned_null" };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[exploration-agent] Goal verification failed: ${msg}`);
+    return { achieved: true, reason: "verification_error" };
+  }
+}
+function parseAgentResultFallback(text) {
+  try {
+    const result = agentResultSchema.parse(JSON.parse(text.trim()));
+    return { ...result, parsed: true };
+  } catch {
+  }
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      const result = agentResultSchema.parse(JSON.parse(jsonMatch[0]));
+      return { ...result, parsed: true };
+    } catch {
+    }
+  }
+  return { goalAchieved: false, summary: text.slice(0, 200), parsed: false };
+}
+
+// src/runbook-generator/intervention-controller.ts
+var InterventionController = class {
+  constructor() {
+    this.pauseRequested = false;
+    this.cancelRequested = false;
+    this.stdinCleanup = null;
+    this.options = {};
+    this.interventions = [];
+  }
+  /**
+   * spinner コールバックを後から設定する
+   */
+  setCallbacks(options) {
+    this.options = options;
+  }
+  /**
+   * stdin の raw mode キーリスナーを開始。
+   * Enter キーまたは p キーで pauseRequested フラグをセット。
+   */
+  startListening() {
+    if (!process.stdin.isTTY) return;
+    const onData = (data) => {
+      if (data[0] === 113 || data[0] === 3) {
+        if (!this.cancelRequested) {
+          this.cancelRequested = true;
+          log.warn("\u23F9 \u30AD\u30E3\u30F3\u30BB\u30EB\u3092\u8981\u6C42\u3057\u307E\u3057\u305F...");
+          this.options.onCancel?.();
+        }
+        return;
+      }
+      if (data[0] === 13 || data[0] === 112) {
+        if (!this.pauseRequested) {
+          this.pauseRequested = true;
+          log.warn("\u23F8 \u4E00\u6642\u505C\u6B62\u3092\u8981\u6C42\u3057\u307E\u3057\u305F\u3002\u6B21\u306E\u30C4\u30FC\u30EB\u547C\u3073\u51FA\u3057\u3067\u505C\u6B62\u3057\u307E\u3059...");
+        }
+      }
+    };
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+    this.stdinCleanup = () => {
+      process.stdin.off("data", onData);
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+      process.stdin.pause();
+    };
+  }
+  /**
+   * 一時停止が要求されているか確認
+   */
+  isPauseRequested() {
+    return this.pauseRequested;
+  }
+  /**
+   * キャンセルが要求されているか確認
+   */
+  isCancelRequested() {
+    return this.cancelRequested;
+  }
+  /**
+   * 一時停止中にユーザーから介入指示を収集。
+   * stdin raw mode を一時的に解除して @clack/prompts を使う。
+   */
+  async collectIntervention(currentStepIndex, currentUrl) {
+    this.suspendRawMode();
+    this.options.onPause?.();
+    try {
+      log.info(
+        `--- \u4E00\u6642\u505C\u6B62 (\u30B9\u30C6\u30C3\u30D7 #${currentStepIndex}, URL: ${currentUrl}) ---`
+      );
+      const action = await promptSelect(
+        "\u64CD\u4F5C\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044",
+        [
+          {
+            value: "guidance",
+            label: "\u30AC\u30A4\u30C0\u30F3\u30B9\u3092\u5165\u529B\u3057\u3066\u7D9A\u884C",
+            hint: "AI\u306E\u63A2\u7D22\u65B9\u91DD\u3092\u4FEE\u6B63"
+          },
+          { value: "abort", label: "\u63A2\u7D22\u3092\u4E2D\u6B62" }
+        ]
+      );
+      if (action === "abort") {
+        return { action: "abort" };
+      }
+      const guidanceText = await promptText("\u30AC\u30A4\u30C0\u30F3\u30B9 (AI\u3078\u306E\u6307\u793A)", {
+        validate: (v) => !v?.trim() ? "\u30AC\u30A4\u30C0\u30F3\u30B9\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044" : void 0
+      });
+      const record = {
+        stepIndex: currentStepIndex,
+        userInstruction: guidanceText.trim(),
+        url: currentUrl,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.interventions.push(record);
+      log.success(`\u30AC\u30A4\u30C0\u30F3\u30B9\u3092\u8A18\u9332\u3057\u307E\u3057\u305F: "${guidanceText.trim()}"`);
+      return { action: "guidance", guidanceText: guidanceText.trim() };
+    } finally {
+      this.pauseRequested = false;
+      this.resumeRawMode();
+      this.options.onResume?.();
+    }
+  }
+  /**
+   * リスナーを停止しリソースを解放
+   */
+  dispose() {
+    if (this.stdinCleanup) {
+      this.stdinCleanup();
+      this.stdinCleanup = null;
+    }
+  }
+  suspendRawMode() {
+    if (this.stdinCleanup) {
+      try {
+        process.stdin.setRawMode(false);
+      } catch {
+      }
+      process.stdin.pause();
+    }
+  }
+  resumeRawMode() {
+    if (this.stdinCleanup) {
+      try {
+        process.stdin.setRawMode(true);
+      } catch {
+      }
+      process.stdin.resume();
+    }
+  }
+};
+
+// src/runbook-generator/explorer.ts
+import { mkdir } from "fs/promises";
+import { join } from "path";
+async function explore(config, options) {
+  const browser = options?.browser ?? new AgentBrowser();
+  const ownsBrowser = !options?.browser;
+  const recordedSteps = [];
+  const debugLogger = createDebugLogger({
+    filePath: config.debugLogPath,
+    console: config.debugConsole
+  });
+  const interventionController = options?.interventionController ?? new InterventionController();
+  const downloadManager = options?.downloadManager ?? (config.screenshotDir ? new DownloadManager(join(config.screenshotDir, "..")) : void 0);
+  if (config.screenshotDir) {
+    await mkdir(config.screenshotDir, { recursive: true });
+  }
+  try {
+    log.step(tf("generator.openingUrl", { url: config.url }));
+    await browser.open(config.url, {
+      headless: config.headless,
+      stealth: config.stealth,
+      proxy: config.proxy
+    });
+    await sleep(1e3);
+    log.info(t("generator.pageLoaded"));
+    if (config.videoDir) {
+      try {
+        await browser.startRecording(config.videoDir);
+        log.info(tf("generator.recordingStarted", { path: config.videoDir }));
+      } catch (e) {
+        log.warn(tf("generator.recordingStartFailed", { error: e instanceof Error ? e.message : String(e) }));
+      }
+    }
+    if (config.screenshotDir) {
+      try {
+        const initialPath = join(config.screenshotDir, "initial.png");
+        await browser.screenshot(initialPath);
+        log.step(tf("generator.screenshotSaved", { path: initialPath }));
+      } catch {
+      }
+    }
+    interventionController.setCallbacks({
+      onPause: () => log.info(t("generator.paused")),
+      onResume: () => log.step(t("generator.waitingForAI")),
+      onCancel: () => log.info(t("generator.cancelledByUser"))
+    });
+    const dataStore = new InMemoryDataStore();
+    let skills = [];
+    if (config.skills && config.skills.length > 0) {
+      await initBuiltinSkills();
+      skills = createSkills(config.skills);
+      log.info(`Skills: ${skills.map((s) => s.name).join(", ")}`);
+    }
+    const maxSteps = config.maxIterations * 3;
+    log.step(t("generator.waitingForAI"));
+    interventionController.startListening();
+    const agentStart = performance.now();
+    const result = await exploreWithAI(browser, recordedSteps, {
+      goal: config.goal,
+      locale: config.locale,
+      contextMarkdown: config.contextMarkdown,
+      secrets: config.secrets,
+      maxIterations: config.maxIterations,
+      stepDelay: config.stepDelay,
+      snapshotFilter: config.snapshotFilter,
+      screenshotDir: config.screenshotDir,
+      debugLogger,
+      interventionController,
+      historyWindow: config.historyWindow,
+      enableMultiModel: config.enableMultiModel,
+      skills: skills.length > 0 ? skills : void 0,
+      aiProvider: options?.aiProvider,
+      onToolCallStart: (stepCount) => {
+        log.step(tf("generator.exploringStep", { current: stepCount + 1, total: maxSteps }));
+      },
+      onToolCallEnd: () => {
+        const lastStep = recordedSteps[recordedSteps.length - 1];
+        if (lastStep && options?.onExplorerStep) {
+          options.onExplorerStep(
+            recordedSteps.length,
+            lastStep.action.description ?? lastStep.action.action,
+            lastStep
+          ).catch(() => {
+          });
+        }
+      }
+    }, dataStore, downloadManager);
+    interventionController.dispose();
+    log.info(tf("generator.explorationComplete", { duration: formatDuration(performance.now() - agentStart) }));
+    const { goalResult } = result;
+    log.info(`Goal achieved: ${goalResult.goalAchieved}`);
+    log.info(`Summary: ${goalResult.summary}`);
+    log.info(`Tokens: prompt=${result.totalTokens.promptTokens}, completion=${result.totalTokens.completionTokens}, total=${result.totalTokens.totalTokens}`);
+    if (dataStore.listCollections().length > 0) {
+      log.info(`Memory collections: ${dataStore.listCollections().join(", ")}`);
+      const memoryOutputDir = config.screenshotDir ? join(config.screenshotDir, "..") : void 0;
+      if (memoryOutputDir) {
+        for (const collection of dataStore.listCollections()) {
+          const filePath = join(memoryOutputDir, `${collection}.json`);
+          await dataStore.writeToFile(collection, filePath, "json");
+          log.info(`Memory data exported: ${filePath}`);
+        }
+      }
+    }
+    if (downloadManager && downloadManager.getDownloads().length > 0) {
+      log.info(`Downloaded files: ${downloadManager.getDownloads().length}`);
+      for (const dl of downloadManager.getDownloads()) {
+        log.info(`  - ${dl.filename} (${dl.path})`);
+      }
+    }
+    await debugLogger.flush();
+    const interventions = interventionController.interventions;
+    const additionalGuidance = interventions.map((iv) => iv.userInstruction);
+    return {
+      recordedSteps,
+      goalAchieved: goalResult.goalAchieved,
+      additionalGuidance,
+      interventions,
+      cancelled: interventionController.isCancelRequested(),
+      downloads: downloadManager?.getDownloads() ?? []
+    };
+  } catch (err) {
+    const interventions = interventionController.interventions;
+    return {
+      recordedSteps,
+      goalAchieved: false,
+      additionalGuidance: interventions.map((iv) => iv.userInstruction),
+      interventions,
+      cancelled: interventionController.isCancelRequested(),
+      downloads: downloadManager?.getDownloads() ?? [],
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  } finally {
+    try {
+      interventionController.dispose();
+    } catch {
+    }
+    if (browser.isRecording()) {
+      try {
+        const result = await browser.stopRecording();
+        for (const p of result.paths) {
+          log.info(tf("generator.recordingComplete", { path: p }));
+        }
+      } catch (e) {
+        log.warn(tf("generator.recordingStopFailed", { error: e instanceof Error ? e.message : String(e) }));
+      }
+    }
+    if (ownsBrowser) {
+      try {
+        await browser.close();
+      } catch {
+      }
+    }
+  }
+}
+
+// src/runbook-generator/runbook-builder.ts
+import { stringify } from "yaml";
+function toActionType(action) {
+  switch (action) {
+    case "fill":
+    case "type":
+      return "input";
+    case "check":
+    case "uncheck":
+    case "click":
+      return "click";
+    case "select":
+      return "select";
+    case "navigate":
+      return "navigate";
+    case "scroll":
+      return "scroll";
+    case "wait":
+      return "wait";
+    case "extract":
+      return "extract";
+    case "download":
+      return "download";
+    case "export":
+      return "export";
+    case "memory_append":
+    case "memory_aggregate":
+      return "memory";
+    case "key":
+      return "key";
+    default:
+      return "click";
+  }
+}
+function categoryToSource(category) {
+  switch (category) {
+    case "credential":
+      return "prompt";
+    case "user_data":
+      return "prompt";
+    case "fixed":
+      return "fixed";
+    case "navigation":
+      return "fixed";
+    default:
+      return "prompt";
+  }
+}
+function buildRunbookYaml(input) {
+  const { goal, startUrl, recordedSteps, goalAchieved, stepDelay, reviewResult, humanGuidance, interventions } = input;
+  const successfulSteps = recordedSteps.filter((s) => s.success);
+  const reviewMap = new Map(
+    reviewResult?.reviewedSteps.map((r) => [r.originalOrdinal, r])
+  );
+  const filteredSteps = reviewResult ? successfulSteps.filter((s) => reviewMap.get(s.ordinal)?.keep !== false) : successfulSteps;
+  const variables = {};
+  const usedVariableNames = /* @__PURE__ */ new Set();
+  filteredSteps.forEach((recorded) => {
+    const { action } = recorded;
+    const actionType = toActionType(action.action);
+    if (actionType === "input" && action.value !== void 0) {
+      const varName = action.variableName ?? `input_${recorded.ordinal}`;
+      if (!usedVariableNames.has(varName)) {
+        usedVariableNames.add(varName);
+        const source = categoryToSource(action.inputCategory);
+        variables[varName] = {
+          source,
+          description: action.description,
+          ...source === "prompt" && {
+            required: true,
+            sensitive: action.inputCategory === "credential"
+          },
+          ...source === "fixed" && { value: action.value }
+        };
+      }
+    }
+  });
+  const steps = filteredSteps.map((recorded, index) => {
+    const actionType = toActionType(recorded.action.action);
+    const review = reviewMap.get(recorded.ordinal);
+    let selector;
+    if (recorded.action.selector) {
+      const ref = recorded.action.selector.replace("@", "");
+      const element = findElementInSnapshot(recorded.snapshotBefore, ref);
+      if (element) {
+        selector = buildSelector(element);
+      } else if (recorded.resolvedElement) {
+        selector = recorded.resolvedElement;
+      } else {
+        selector = { tagName: "unknown" };
+      }
+    }
+    let value;
+    if (actionType === "input" && recorded.action.value !== void 0) {
+      const varName = recorded.action.variableName ?? `input_${recorded.ordinal}`;
+      value = `{{${varName}}}`;
+    }
+    const step = {
+      ordinal: index,
+      description: recorded.action.description,
+      action: {
+        type: actionType,
+        ...selector && { selector },
+        ...actionType === "input" && value !== void 0 && { value },
+        ...actionType === "select" && recorded.action.value !== void 0 && {
+          optionText: recorded.action.value
+        },
+        ...actionType === "navigate" && recorded.action.value && {
+          url: recorded.action.value
+        },
+        ...actionType === "extract" && recorded.action.script && {
+          script: recorded.action.script
+        },
+        ...actionType === "download" && recorded.action.downloadPath && {
+          downloadPath: recorded.action.downloadPath
+        },
+        ...actionType === "export" && recorded.action.exportCollection && {
+          exportCollection: recorded.action.exportCollection
+        },
+        ...actionType === "export" && recorded.action.exportFormat && {
+          exportFormat: recorded.action.exportFormat
+        },
+        ...actionType === "export" && recorded.action.exportPath && {
+          exportPath: recorded.action.exportPath
+        },
+        ...actionType === "key" && {
+          keys: recorded.action.keys ?? recorded.action.value
+        }
+      },
+      url: recorded.url,
+      riskLevel: review?.riskLevel ?? "low",
+      requiresConfirmation: review?.requiresConfirmation ?? false
+    };
+    const captures = buildCaptures(recorded.action.suggestedCaptures);
+    if (captures.length > 0) {
+      step.captures = captures;
+    }
+    if (recorded.action.action === "memory_append" && recorded.action.memoryCollection) {
+      step.memoryOperations = [{
+        type: "append",
+        collection: recorded.action.memoryCollection,
+        source: recorded.action.variableName ?? "extractedData"
+      }];
+    } else if (recorded.action.action === "memory_aggregate" && recorded.action.aggregation) {
+      const agg = recorded.action.aggregation;
+      step.memoryOperations = [{
+        type: "aggregate",
+        collection: agg.collection,
+        field: agg.field,
+        operation: agg.operation,
+        outputVariable: agg.outputVariable
+      }];
+    }
+    return step;
+  });
+  const baseUrl = new URL(startUrl).origin;
+  const runbook = {
+    title: goal,
+    settings: {
+      baseUrl,
+      defaultTimeout: 1e4,
+      pauseBetweenSteps: stepDelay,
+      stopOnError: true
+    },
+    metadata: {
+      startUrl,
+      goal,
+      goalAchieved,
+      totalSteps: filteredSteps.length,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...input.skills && input.skills.length > 0 && { skills: input.skills }
+    },
+    context: input.contextMarkdown
+  };
+  if (Object.keys(variables).length > 0) {
+    runbook.variables = variables;
+  }
+  runbook.steps = steps;
+  const allNotes = [];
+  if (humanGuidance && humanGuidance.length > 0) {
+    allNotes.push(
+      ...humanGuidance.map((g, i) => `[\u65B9\u91DD\u4FEE\u6B63 ${i + 1}] ${g}`)
+    );
+  }
+  if (interventions && interventions.length > 0) {
+    allNotes.push(
+      ...interventions.map(
+        (iv) => `[\u63A2\u7D22\u4E2D\u4ECB\u5165 \u30B9\u30C6\u30C3\u30D7#${iv.stepIndex}] ${iv.userInstruction}`
+      )
+    );
+  }
+  if (allNotes.length > 0) {
+    runbook.notes = allNotes.join("\n");
+  }
+  ParsedRunbookSchema.parse(runbook);
+  return stringify(runbook, { lineWidth: 120 });
+}
+function buildCaptures(suggested) {
+  if (!suggested || suggested.length === 0) return [];
+  return suggested.map((c) => ({
+    name: c.name,
+    strategy: c.strategy,
+    required: false,
+    ...c.description && { description: c.description },
+    ...c.pattern && { pattern: c.pattern },
+    ...c.group !== void 0 && c.group !== 1 && { group: c.group },
+    ...c.prompt && { prompt: c.prompt },
+    ...c.expression && { expression: c.expression }
+  }));
+}
+
+// src/runbook-generator/prompts.ts
+import { z as z3 } from "zod";
+var reviewResponseSchema = z3.object({
+  reviewedSteps: z3.array(z3.object({
+    originalOrdinal: z3.number(),
+    keep: z3.boolean(),
+    removalReason: z3.string().optional(),
+    riskLevel: z3.enum(["low", "medium", "high"]),
+    requiresConfirmation: z3.boolean(),
+    confirmationReason: z3.string().optional()
+  })),
+  summary: z3.string()
+});
+function createReviewPrompt(goal, recordedSteps, goalAchieved, interventions, locale) {
+  const system = getReviewSystemPrompt(locale);
+  const userPrompt = createReviewUserPrompt(goal, recordedSteps, goalAchieved, interventions, locale);
+  return { system, userPrompt };
+}
+
+export {
+  explore,
+  buildRunbookYaml,
+  reviewResponseSchema,
+  createReviewPrompt
+};
+//# sourceMappingURL=chunk-IGFCYKHC.js.map