@basemachina/agentic-browser-cli 0.3.0

package/dist/instruction-generator-5RPRYTVR.js

@@ -0,0 +1,2470 @@
+#!/usr/bin/env node
+import {
+  AgentBrowser,
+  DownloadManager,
+  InMemoryDataStore,
+  classifyFailure,
+  createDebugLogger,
+  createReviewUserPrompt,
+  filterSnapshot,
+  findElementInSnapshot,
+  formatAiMetricsSection,
+  formatDebugLogSections,
+  formatDuration,
+  formatFailureCategoryDistribution,
+  formatPerformanceBottlenecks,
+  formatRuntimeEnvironment,
+  getAgentInstructions,
+  getInitialUserMessage,
+  getReviewSystemPrompt,
+  loadSecrets,
+  noopLogger,
+  parseAllElements,
+  parseAndAppendToMemory,
+  readDebugLog,
+  renderOptionsMarkdown,
+  serializeGeneratorOptions,
+  sleep
+} from "./chunk-U6GPCKY3.js";
+import {
+  getRawArgs,
+  parseModelConfig,
+  readContextFile
+} from "./chunk-KDEQ2AAE.js";
+import {
+  getModel,
+  globalMetrics,
+  initModel,
+  trackedGenerateObject,
+  trackedGenerateText
+} from "./chunk-XAEHXRUC.js";
+import {
+  ParsedInstructionSchema,
+  cancel,
+  initLocale,
+  intro,
+  log,
+  note,
+  outro,
+  promptMultiselect,
+  promptSelect,
+  promptText,
+  spinner,
+  t,
+  tf
+} from "./chunk-VNQYQSMI.js";
+
+// src/instruction-generator/index.ts
+import { writeFile, mkdir as mkdir2 } from "fs/promises";
+import { dirname } from "path";
+
+// src/instruction-generator/config.ts
+import { parseArgs as nodeParseArgs } from "util";
+async function parseArgs() {
+  const args = getRawArgs();
+  const { values } = nodeParseArgs({
+    args,
+    options: {
+      url: { type: "string" },
+      goal: { type: "string" },
+      output: { type: "string" },
+      screenshots: { type: "string" },
+      context: { type: "string" },
+      secrets: { type: "string" },
+      "max-iterations": { type: "string" },
+      "step-delay": { type: "string" },
+      "stall-check-interval": { type: "string" },
+      "history-window": { type: "string" },
+      "max-failures": { type: "string" },
+      "no-snapshot-filter": { type: "boolean" },
+      "debug-log": { type: "string" },
+      debug: { type: "boolean" },
+      headless: { type: "string" },
+      model: { type: "string" },
+      "model-provider": { type: "string" },
+      "model-base-url": { type: "string" },
+      "model-selector": { type: "string" },
+      "model-extraction": { type: "string" },
+      "model-exploration": { type: "string" },
+      "model-review": { type: "string" },
+      "model-fallback": { type: "string" },
+      "model-exploration-light": { type: "string" },
+      "enable-multi-model": { type: "boolean" },
+      video: { type: "string" },
+      locale: { type: "string" },
+      stealth: { type: "boolean" },
+      proxy: { type: "string" }
+    },
+    strict: true
+  });
+  initLocale(values.locale);
+  if (!values.url) {
+    cancel(t("cli.urlRequired"));
+    process.exit(1);
+  }
+  if (!values.goal) {
+    cancel(t("cli.goalRequired"));
+    process.exit(1);
+  }
+  if (!values.output) {
+    cancel(t("cli.outputRequired"));
+    process.exit(1);
+  }
+  const contextMarkdown = await readContextFile(values.context);
+  const secrets = await loadSecrets(values.secrets);
+  const aiModelConfig = parseModelConfig(values);
+  return {
+    url: values.url,
+    goal: values.goal,
+    output: values.output,
+    screenshotDir: values.screenshots,
+    contextMarkdown,
+    secrets,
+    maxIterations: values["max-iterations"] ? Number.parseInt(values["max-iterations"], 10) : 20,
+    stepDelay: values["step-delay"] ? Number.parseInt(values["step-delay"], 10) : 500,
+    headless: values.headless !== "false",
+    stallCheckInterval: values["stall-check-interval"] ? Number.parseInt(values["stall-check-interval"], 10) : 3,
+    historyWindow: values["history-window"] ? Number.parseInt(values["history-window"], 10) : 10,
+    maxConsecutiveFailures: values["max-failures"] ? Number.parseInt(values["max-failures"], 10) : 3,
+    snapshotFilter: !values["no-snapshot-filter"],
+    debugLogPath: values["debug-log"],
+    debugConsole: values.debug ?? false,
+    videoDir: values.video,
+    aiModelConfig,
+    enableMultiModel: values["enable-multi-model"] ?? false,
+    stealth: values.stealth ?? false,
+    proxy: values.proxy
+  };
+}
+
+// src/instruction-generator/exploration-agent.ts
+import { stepCountIs, Output } from "ai";
+import { z as z2 } from "zod";
+
+// src/instruction-generator/browser-tool.ts
+import { tool } from "ai";
+import { z } from "zod";
+
+// 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/instruction-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"
+  ]),
+  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()
+});
+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 = "";
+  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) => {
+      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();
+        let finalSnapshot2 = config.snapshotFilter ? filterSnapshot(snapshot) : 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 }
+        });
+        return {
+          results: [],
+          snapshot: finalSnapshot2,
+          url: currentUrl2,
+          nudgeMessage: emptyNudge,
+          stepCount: recordedSteps.length
+        };
+      }
+      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 = action.value ?? lastExtractedData ?? "";
+          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 = 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-NZ7QJNJW.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 = 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 = 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 = 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;
+        }
+        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;
+          }
+        } 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;
+          finalSnapshot = config.snapshotFilter ? filterSnapshot(postSnapshot, { filledSelectors }) : postSnapshot;
+          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;
+        finalSnapshot = config.snapshotFilter ? filterSnapshot(postSnapshot, { filledSelectors }) : postSnapshot;
+        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 extractedDataPreview = hasExtractAction && lastExtractedData ? truncateExtractedData(lastExtractedData, 500) : void 0;
+      const keepRecent = 5;
+      if (recordedSteps.length > keepRecent) {
+        recordedSteps[recordedSteps.length - keepRecent - 1].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 } : {}
+      };
+    }
+  });
+}
+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/instruction-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
+  };
+  const browserTool = createBrowserTool(browser, recordedSteps, toolConfig, dataStore, downloadManager);
+  const totalMaxSteps = config.maxIterations * 3;
+  const systemMessage = {
+    role: "system",
+    content: getAgentInstructions(config.goal, config.contextMarkdown, config.secrets),
+    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 = 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 result = await trackedGenerateText("exploration", {
+    model: getModel("exploration"),
+    messages: [
+      systemMessage,
+      { role: "user", content: getInitialUserMessage() }
+    ],
+    tools: { browser: browserTool },
+    output: Output.object({ schema: agentResultSchema }),
+    // +1: 構造化出力の生成は追加ステップとしてカウントされる
+    stopWhen: [stepCountIs(totalMaxSteps + 1)],
+    prepareStep
+  });
+  const goalResult = result.output ?? parseAgentResultFallback(result.text);
+  return {
+    goalResult,
+    totalTokens: {
+      promptTokens: result.usage.inputTokens ?? 0,
+      completionTokens: result.usage.outputTokens ?? 0,
+      totalTokens: (result.usage.inputTokens ?? 0) + (result.usage.outputTokens ?? 0)
+    }
+  };
+}
+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("")
+});
+function parseAgentResultFallback(text) {
+  try {
+    return agentResultSchema.parse(JSON.parse(text.trim()));
+  } catch {
+  }
+  const jsonMatch = text.match(/\{[\s\S]*\}/);
+  if (jsonMatch) {
+    try {
+      return agentResultSchema.parse(JSON.parse(jsonMatch[0]));
+    } catch {
+    }
+  }
+  const achieved = /ゴール.*達成|goal.*achieved|完了しました/i.test(text);
+  return { goalAchieved: achieved, summary: text.slice(0, 200) };
+}
+
+// src/instruction-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/instruction-generator/explorer.ts
+import { mkdir } from "fs/promises";
+import { join } from "path";
+async function explore(config) {
+  const browser = new AgentBrowser();
+  const recordedSteps = [];
+  const debugLogger = createDebugLogger({
+    filePath: config.debugLogPath,
+    console: config.debugConsole
+  });
+  const interventionController = new InterventionController();
+  if (config.screenshotDir) {
+    await mkdir(config.screenshotDir, { recursive: true });
+  }
+  try {
+    const s = spinner();
+    s.start(`${config.url} \u3092\u958B\u3044\u3066\u3044\u307E\u3059...`);
+    await browser.open(config.url, {
+      headless: config.headless,
+      stealth: config.stealth,
+      proxy: config.proxy
+    });
+    await sleep(1e3);
+    s.stop("\u30DA\u30FC\u30B8\u8AAD\u307F\u8FBC\u307F\u5B8C\u4E86");
+    if (config.videoDir) {
+      try {
+        await browser.startRecording(config.videoDir);
+        log.info(`\u9332\u753B\u958B\u59CB: ${config.videoDir}`);
+      } catch (e) {
+        log.warn(`\u9332\u753B\u958B\u59CB\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    if (config.screenshotDir) {
+      try {
+        const initialPath = join(config.screenshotDir, "initial.png");
+        await browser.screenshot(initialPath);
+        log.step(`Initial screenshot saved: ${initialPath}`);
+      } catch {
+      }
+    }
+    interventionController.setCallbacks({
+      onPause: () => s.stop("\u23F8 \u4E00\u6642\u505C\u6B62"),
+      onResume: () => s.start("\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u63A2\u7D22\u4E2D... [Enter: \u4E00\u6642\u505C\u6B62 / q: \u30AD\u30E3\u30F3\u30BB\u30EB]"),
+      onCancel: () => s.stop("\u23F9 \u30AD\u30E3\u30F3\u30BB\u30EB")
+    });
+    const dataStore = new InMemoryDataStore();
+    const outputDir = config.screenshotDir ? join(config.screenshotDir, "..") : void 0;
+    const downloadManager = outputDir ? new DownloadManager(outputDir) : void 0;
+    const maxSteps = config.maxIterations * 3;
+    s.start(
+      `\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u63A2\u7D22\u4E2D (\u6700\u5927 ${maxSteps} \u30B9\u30C6\u30C3\u30D7)... [Enter: \u4E00\u6642\u505C\u6B62 / q: \u30AD\u30E3\u30F3\u30BB\u30EB]`
+    );
+    interventionController.startListening();
+    const agentStart = performance.now();
+    const result = await exploreWithAI(browser, recordedSteps, {
+      goal: config.goal,
+      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
+    }, dataStore, downloadManager);
+    interventionController.dispose();
+    s.stop(`\u63A2\u7D22\u5B8C\u4E86 (${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(", ")}`);
+      if (outputDir) {
+        for (const collection of dataStore.listCollections()) {
+          const filePath = join(outputDir, `${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()
+    };
+  } catch (err) {
+    const interventions = interventionController.interventions;
+    return {
+      recordedSteps,
+      goalAchieved: false,
+      additionalGuidance: interventions.map((iv) => iv.userInstruction),
+      interventions,
+      cancelled: interventionController.isCancelRequested(),
+      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(`\u9332\u753B\u5B8C\u4E86: ${p}`);
+        }
+      } catch (e) {
+        log.warn(`\u9332\u753B\u505C\u6B62\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    try {
+      await browser.close();
+    } catch {
+    }
+  }
+}
+
+// src/instruction-generator/instruction-builder.ts
+import { stringify } from "yaml";
+
+// 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/instruction-generator/instruction-builder.ts
+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";
+    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 buildInstructionYaml(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 {
+        selector = { tagName: "unknown", ariaLabel: recorded.action.description };
+      }
+    }
+    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
+        }
+      },
+      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 instruction = {
+    title: goal,
+    settings: {
+      baseUrl,
+      defaultTimeout: 1e4,
+      pauseBetweenSteps: stepDelay,
+      stopOnError: true
+    },
+    metadata: {
+      startUrl,
+      goal,
+      goalAchieved,
+      totalSteps: filteredSteps.length,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+  if (Object.keys(variables).length > 0) {
+    instruction.variables = variables;
+  }
+  instruction.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) {
+    instruction.notes = allNotes.join("\n");
+  }
+  ParsedInstructionSchema.parse(instruction);
+  return stringify(instruction, { 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/instruction-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) {
+  const system = getReviewSystemPrompt();
+  const userPrompt = createReviewUserPrompt(goal, recordedSteps, goalAchieved, interventions);
+  return { system, userPrompt };
+}
+
+// src/instruction-generator/review-editor.ts
+function buildSummaryText(reviewResult, recordedSteps, humanGuidance) {
+  const lines = [];
+  const keptSteps = reviewResult.reviewedSteps.filter((s) => s.keep);
+  if (keptSteps.length > 0) {
+    lines.push(t("review.keptSteps"));
+    for (const step of keptSteps) {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      lines.push(
+        `  #${step.originalOrdinal}: ${desc} [risk: ${step.riskLevel}]`
+      );
+    }
+  }
+  const confirmSteps = keptSteps.filter((s) => s.requiresConfirmation);
+  lines.push("");
+  lines.push(t("review.confirmationRequired"));
+  if (confirmSteps.length > 0) {
+    for (const step of confirmSteps) {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      const reason = step.confirmationReason ? ` \u2014 ${step.confirmationReason}` : "";
+      lines.push(
+        `  #${step.originalOrdinal}: ${desc} [risk: ${step.riskLevel}]${reason}`
+      );
+    }
+  } else {
+    lines.push("  " + t("common.none"));
+  }
+  const removedSteps = reviewResult.reviewedSteps.filter((s) => !s.keep);
+  if (removedSteps.length > 0) {
+    lines.push("");
+    lines.push(t("review.removedSteps"));
+    for (const step of removedSteps) {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      const reason = step.removalReason ?? "";
+      lines.push(`  #${step.originalOrdinal}: ${desc} (\u7406\u7531: ${reason})`);
+    }
+  }
+  const captureSteps = recordedSteps.filter(
+    (r) => r.action.suggestedCaptures && r.action.suggestedCaptures.length > 0
+  );
+  if (captureSteps.length > 0) {
+    lines.push("");
+    lines.push(t("review.capturedValues"));
+    for (const r of captureSteps) {
+      for (const c of r.action.suggestedCaptures) {
+        lines.push(
+          `  Step #${r.ordinal} \u2192 ${c.name} (${c.strategy}${c.pattern ? `: ${c.pattern}` : ""})`
+        );
+      }
+    }
+  }
+  lines.push("");
+  lines.push(t("review.notes"));
+  if (humanGuidance.length > 0) {
+    for (const [i, n] of humanGuidance.entries()) {
+      lines.push(`  ${tf("review.guidancePrefix", { index: i + 1 })} ${n}`);
+    }
+  } else {
+    lines.push("  " + t("common.none"));
+  }
+  lines.push("");
+  lines.push(tf("review.summaryLabel", { summary: reviewResult.summary }));
+  return lines.join("\n");
+}
+function cloneReviewResult(r) {
+  return {
+    reviewedSteps: r.reviewedSteps.map((s) => ({ ...s })),
+    summary: r.summary
+  };
+}
+function deriveSuggestedNotes(reviewResult, recordedSteps) {
+  const suggestions = [];
+  const highRiskSteps = reviewResult.reviewedSteps.filter(
+    (s) => s.keep && s.riskLevel === "high"
+  );
+  if (highRiskSteps.length > 0) {
+    const ordinals = highRiskSteps.map((s) => `#${s.originalOrdinal}`).join(", ");
+    suggestions.push(tf("review.highRiskNote", { ordinals }));
+  }
+  const credentialSteps = recordedSteps.filter(
+    (r) => r.action.inputCategory === "credential"
+  );
+  if (credentialSteps.length > 0) {
+    suggestions.push(t("review.credentialNote"));
+  }
+  const removedCount = reviewResult.reviewedSteps.filter(
+    (s) => !s.keep
+  ).length;
+  if (removedCount >= 3) {
+    suggestions.push(tf("review.removedStepsNote", { count: removedCount }));
+  }
+  if (reviewResult.summary) {
+    suggestions.push(`AI\u30EC\u30D3\u30E5\u30FC\u8981\u7D04: ${reviewResult.summary}`);
+  }
+  return suggestions;
+}
+async function handleToggleConfirmation(reviewResult, recordedSteps) {
+  const keptSteps = reviewResult.reviewedSteps.filter((s) => s.keep);
+  if (keptSteps.length === 0) {
+    log.warn("\u4FDD\u6301\u3055\u308C\u308B\u30B9\u30C6\u30C3\u30D7\u304C\u3042\u308A\u307E\u305B\u3093\u3002");
+    return;
+  }
+  const initialValues = keptSteps.filter((s) => s.requiresConfirmation).map((s) => s.originalOrdinal);
+  const selected = await promptMultiselect(
+    t("review.selectConfirmSteps"),
+    keptSteps.map((step) => {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      return {
+        value: step.originalOrdinal,
+        label: `#${step.originalOrdinal}: ${desc}`,
+        hint: `risk: ${step.riskLevel}`
+      };
+    }),
+    { initialValues }
+  );
+  for (const step of keptSteps) {
+    step.requiresConfirmation = selected.includes(step.originalOrdinal);
+  }
+}
+async function handleEditNotes(humanGuidance, reviewResult, recordedSteps) {
+  const suggestions = deriveSuggestedNotes(reviewResult, recordedSteps);
+  const options = [
+    { value: "add_custom", label: t("review.addCustomNote") }
+  ];
+  if (suggestions.length > 0) {
+    options.push({
+      value: "add_suggested",
+      label: t("review.addSuggestedNote"),
+      hint: `${suggestions.length} ${t("common.items")}`
+    });
+  }
+  if (humanGuidance.length > 0) {
+    options.push({
+      value: "delete",
+      label: t("review.deleteNote"),
+      hint: `${humanGuidance.length} ${t("common.items")}`
+    });
+  }
+  const action = await promptSelect(
+    t("review.selectNotesAction"),
+    options
+  );
+  switch (action) {
+    case "add_custom": {
+      const content = await promptText(t("review.noteContent"), {
+        validate: (v) => !v?.trim() ? t("review.noteContentRequired") : void 0
+      });
+      humanGuidance.push(content.trim());
+      log.success(tf("review.notesAdded", { count: 1 }));
+      break;
+    }
+    case "add_suggested": {
+      const selected = await promptMultiselect(
+        "\u8FFD\u52A0\u3059\u308B\u30CE\u30FC\u30C8\u3092\u9078\u629E",
+        suggestions.map((s, i) => ({
+          value: i,
+          label: s
+        }))
+      );
+      for (const idx of selected) {
+        humanGuidance.push(suggestions[idx]);
+      }
+      log.success(tf("review.notesAdded", { count: selected.length }));
+      break;
+    }
+    case "delete": {
+      const toDelete = await promptMultiselect(
+        "\u524A\u9664\u3059\u308B\u30CE\u30FC\u30C8\u3092\u9078\u629E",
+        humanGuidance.map((g, i) => ({
+          value: i,
+          label: `${tf("review.guidancePrefix", { index: i + 1 })} ${g}`
+        }))
+      );
+      for (const idx of [...toDelete].sort((a, b) => b - a)) {
+        humanGuidance.splice(idx, 1);
+      }
+      log.success(tf("review.notesDeleted", { count: toDelete.length }));
+      break;
+    }
+  }
+}
+async function handleEditCaptures(recordedSteps) {
+  const action = await promptSelect(
+    t("review.selectCaptureAction"),
+    [
+      { value: "accept_all", label: t("review.acceptAllCaptures") },
+      { value: "reject", label: t("review.rejectCaptures") },
+      { value: "add", label: t("review.addCapture") }
+    ]
+  );
+  switch (action) {
+    case "accept_all": {
+      log.success(t("review.allCapturesAccepted"));
+      break;
+    }
+    case "reject": {
+      const captureSteps = recordedSteps.filter(
+        (r) => r.action.suggestedCaptures && r.action.suggestedCaptures.length > 0
+      );
+      if (captureSteps.length === 0) {
+        log.warn(t("review.noCapturesAvailable"));
+        break;
+      }
+      const allCaptures = [];
+      for (const r of captureSteps) {
+        for (const c of r.action.suggestedCaptures) {
+          allCaptures.push({
+            value: `${r.ordinal}:${c.name}`,
+            label: `Step #${r.ordinal} \u2192 ${c.name} (${c.strategy})`
+          });
+        }
+      }
+      const toReject = await promptMultiselect(
+        t("review.selectCapturesToReject"),
+        allCaptures
+      );
+      for (const key of toReject) {
+        const [ordStr, name] = key.split(":");
+        const step = recordedSteps.find((r) => r.ordinal === Number(ordStr));
+        if (step?.action.suggestedCaptures) {
+          step.action.suggestedCaptures = step.action.suggestedCaptures.filter(
+            (c) => c.name !== name
+          );
+        }
+      }
+      log.success(tf("review.capturesRejected", { count: toReject.length }));
+      break;
+    }
+    case "add": {
+      const ordinalStr = await promptText(t("review.captureStepNumber"), {
+        validate: (v) => {
+          if (!v?.trim()) return t("review.captureStepRequired");
+          if (Number.isNaN(Number(v))) return t("review.captureStepNumeric");
+          return void 0;
+        }
+      });
+      const ordinal = Number(ordinalStr);
+      const step = recordedSteps.find((r) => r.ordinal === ordinal);
+      if (!step) {
+        log.warn(tf("review.stepNotFound", { ordinal }));
+        break;
+      }
+      const name = await promptText(t("review.captureVarName"), {
+        validate: (v) => !v?.trim() ? t("review.captureVarRequired") : void 0
+      });
+      const strategy = await promptSelect(
+        t("review.captureStrategy"),
+        [
+          { value: "snapshot", label: t("review.strategySnapshot") },
+          { value: "url", label: t("review.strategyUrl") },
+          { value: "ai", label: t("review.strategyAi") },
+          { value: "expression", label: t("review.strategyExpression") }
+        ]
+      );
+      const newCapture = { name, strategy };
+      if (strategy === "snapshot" || strategy === "url") {
+        newCapture.pattern = await promptText(t("review.regexPattern"));
+      } else if (strategy === "ai") {
+        newCapture.prompt = await promptText(t("review.aiExtractionPrompt"));
+      } else if (strategy === "expression") {
+        newCapture.expression = await promptText(t("review.templateExpression"));
+      }
+      if (!step.action.suggestedCaptures) {
+        step.action.suggestedCaptures = [];
+      }
+      step.action.suggestedCaptures.push(newCapture);
+      log.success(tf("review.captureAdded", { ordinal, name }));
+      break;
+    }
+  }
+}
+async function promptReviewEdits(reviewResult, recordedSteps, humanGuidance) {
+  const edited = cloneReviewResult(reviewResult);
+  const editedGuidance = [...humanGuidance];
+  while (true) {
+    const summaryText = buildSummaryText(edited, recordedSteps, editedGuidance);
+    note(summaryText, t("review.reviewResult"));
+    const hasCaptureSteps = recordedSteps.some(
+      (r) => r.action.suggestedCaptures && r.action.suggestedCaptures.length > 0
+    );
+    const menuOptions = [
+      { value: "confirm", label: t("review.confirm"), hint: t("review.confirmHint") },
+      {
+        value: "toggle_confirmation",
+        label: t("review.toggleConfirmation"),
+        hint: "multiselect"
+      },
+      ...hasCaptureSteps ? [
+        {
+          value: "edit_captures",
+          label: t("review.editCaptures"),
+          hint: t("review.editCapturesHint")
+        }
+      ] : [],
+      { value: "edit_notes", label: t("review.editNotes") }
+    ];
+    const action = await promptSelect(
+      t("review.selectAction"),
+      menuOptions
+    );
+    if (action === "confirm") {
+      break;
+    }
+    switch (action) {
+      case "toggle_confirmation":
+        await handleToggleConfirmation(edited, recordedSteps);
+        break;
+      case "edit_captures":
+        await handleEditCaptures(recordedSteps);
+        break;
+      case "edit_notes":
+        await handleEditNotes(editedGuidance, edited, recordedSteps);
+        break;
+    }
+  }
+  return {
+    reviewResult: edited,
+    humanGuidance: editedGuidance
+  };
+}
+
+// src/instruction-generator/report-generator.ts
+function formatOutcome(outcome) {
+  switch (outcome) {
+    case "cancelled":
+      return "Cancelled by user";
+    case "goal_achieved":
+      return "Goal achieved";
+    case "goal_not_achieved":
+      return "Goal not achieved";
+    case "error":
+      return "Error";
+  }
+}
+function toReportableSteps(steps) {
+  return steps.map((s) => ({
+    ordinal: s.ordinal + 1,
+    description: `${s.action.action}: ${s.action.description}`,
+    status: s.success ? "success" : "failed",
+    durationMs: s.durationMs ?? 0,
+    error: s.error,
+    failureCategory: s.failureCategory
+  }));
+}
+async function generateExplorationReport(input) {
+  const lines = [];
+  lines.push("# Exploration Report");
+  lines.push("");
+  lines.push("## Session Info");
+  lines.push(`- **Date**: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`- **Goal**: ${input.goal}`);
+  lines.push(`- **Start URL**: ${input.startUrl}`);
+  lines.push(`- **Outcome**: ${formatOutcome(input.outcome)}`);
+  lines.push("");
+  if (input.cliOptions && input.cliOptions.length > 0) {
+    lines.push("## CLI Options");
+    lines.push(...renderOptionsMarkdown(input.cliOptions));
+    lines.push("");
+  }
+  lines.push("## User Feedback");
+  if (input.userFeedback) {
+    lines.push(input.userFeedback);
+  } else {
+    lines.push("(No feedback provided)");
+  }
+  lines.push("");
+  if (input.errorMessage) {
+    lines.push("## Error Details");
+    lines.push("```");
+    lines.push(input.errorMessage);
+    lines.push("```");
+    lines.push("");
+  }
+  const successCount = input.recordedSteps.filter((s) => s.success).length;
+  const failedCount = input.recordedSteps.filter((s) => !s.success).length;
+  lines.push("## Execution Summary");
+  lines.push(`- **Total Steps**: ${input.recordedSteps.length}`);
+  lines.push(`- **Successful**: ${successCount}`);
+  lines.push(`- **Failed**: ${failedCount}`);
+  lines.push(`- **Interventions**: ${input.interventions.length}`);
+  if (input.totalDurationMs !== void 0) {
+    lines.push(`- **Duration**: ${input.totalDurationMs}ms`);
+  }
+  lines.push("");
+  if (input.recordedSteps.length > 0) {
+    lines.push("## Recorded Steps");
+    for (const step of input.recordedSteps) {
+      const tag = step.success ? "DONE" : "FAILED";
+      const errorInfo = !step.success && step.error ? ` \u2014 Error: ${step.error}` : "";
+      const category = step.failureCategory ? ` [${step.failureCategory}]` : "";
+      const duration = step.durationMs !== void 0 ? ` (${step.durationMs}ms)` : "";
+      lines.push(
+        `${step.ordinal + 1}. [${tag}] ${step.action.action}: ${step.action.description} (URL: ${step.url})${duration}${errorInfo}${category}`
+      );
+    }
+    lines.push("");
+  }
+  if (input.interventions.length > 0) {
+    lines.push("## Interventions");
+    for (const iv of input.interventions) {
+      lines.push(
+        `- **Step ${iv.stepIndex}** (${iv.timestamp}): "${iv.userInstruction}" (URL: ${iv.url})`
+      );
+    }
+    lines.push("");
+  }
+  const debugEntries = input.debugLogPath ? await readDebugLog(input.debugLogPath) : [];
+  const reportableSteps = toReportableSteps(input.recordedSteps);
+  const hasInsights = input.aiMetrics && input.aiMetrics.totalCalls > 0 || reportableSteps.some((s) => s.status === "failed") || reportableSteps.some((s) => s.durationMs > 3e3) || debugEntries.length > 0;
+  if (hasInsights) {
+    lines.push("## System Insights");
+    lines.push("");
+    lines.push("> agentic-browser \u306E\u6A5F\u80FD\u6539\u5584\u30FB\u30D0\u30B0\u4FEE\u6B63\u306E\u305F\u3081\u306E\u5206\u6790\u60C5\u5831");
+    lines.push("");
+    lines.push(...formatRuntimeEnvironment());
+    if (input.aiMetrics && input.aiMetrics.totalCalls > 0) {
+      lines.push(...formatAiMetricsSection(input.aiMetrics));
+    }
+    const failedSteps = reportableSteps.filter((s) => s.status === "failed");
+    lines.push(...formatFailureCategoryDistribution(failedSteps));
+    lines.push(...formatPerformanceBottlenecks(reportableSteps));
+  }
+  lines.push(...formatDebugLogSections(debugEntries));
+  return lines.join("\n");
+}
+
+// src/instruction-generator/index.ts
+async function main() {
+  const totalStart = performance.now();
+  const config = await parseArgs();
+  await initModel(config.aiModelConfig);
+  const cliOptions = serializeGeneratorOptions(config);
+  intro("instruction-generator");
+  log.info(`URL:    ${config.url}`);
+  log.info(`Goal:   ${config.goal}`);
+  log.info(`Output: ${config.output}`);
+  log.info(`Max iterations: ${config.maxIterations}`);
+  log.info(`Step delay: ${config.stepDelay}ms`);
+  log.info(`Headless: ${config.headless}`);
+  if (config.contextMarkdown) {
+    log.info(`Context: loaded (${config.contextMarkdown.split("\n").length} lines)`);
+    log.info("--- Context Markdown ---");
+    log.info(config.contextMarkdown);
+    log.info("--- End Context ---");
+  }
+  if (config.secrets && Object.keys(config.secrets.values).length > 0) {
+    log.info(`Secrets: ${Object.keys(config.secrets.values).length} keys loaded`);
+  }
+  const exploreStart = performance.now();
+  const { recordedSteps, goalAchieved, additionalGuidance, interventions, cancelled, error: exploreError } = await explore(config);
+  log.info(`Steps recorded: ${recordedSteps.length}`);
+  log.info(`Goal achieved: ${goalAchieved}`);
+  if (cancelled) {
+    log.warn("Exploration was cancelled by user.");
+  }
+  if (interventions.length > 0) {
+    log.info(`User interventions: ${interventions.length}`);
+  }
+  log.info(`Exploration completed (${formatDuration(performance.now() - exploreStart)})`);
+  if (exploreError) {
+    log.error(`Exploration failed: ${exploreError.message}`);
+    const report = await generateExplorationReport({
+      goal: config.goal,
+      startUrl: config.url,
+      outcome: "error",
+      userFeedback: "",
+      recordedSteps,
+      interventions,
+      debugLogPath: config.debugLogPath,
+      errorMessage: exploreError.stack ?? exploreError.message,
+      cliOptions,
+      aiMetrics: globalMetrics.getSummary(),
+      totalDurationMs: Math.round(performance.now() - totalStart)
+    });
+    const reportPath = config.output.replace(/\.\w+$/, "-report.md");
+    await mkdir2(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, report, "utf-8");
+    log.info(`Error report written to: ${reportPath}`);
+    outro(`Exploration failed. Report: ${reportPath}`);
+    process.exit(1);
+  }
+  if (cancelled || !goalAchieved) {
+    const userFeedback = await promptText(
+      t("generator.feedbackPrompt"),
+      { validate: () => void 0 }
+    );
+    const report = await generateExplorationReport({
+      goal: config.goal,
+      startUrl: config.url,
+      outcome: cancelled ? "cancelled" : "goal_not_achieved",
+      userFeedback: userFeedback?.trim() ?? "",
+      recordedSteps,
+      interventions,
+      debugLogPath: config.debugLogPath,
+      cliOptions,
+      aiMetrics: globalMetrics.getSummary(),
+      totalDurationMs: Math.round(performance.now() - totalStart)
+    });
+    const reportPath = config.output.replace(/\.\w+$/, "-report.md");
+    await mkdir2(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, report, "utf-8");
+    log.info(`Report written to: ${reportPath}`);
+    if (cancelled) {
+      outro(t("generator.cancelled"));
+      process.exit(0);
+    }
+  }
+  if (recordedSteps.length === 0) {
+    log.error("No steps recorded. Cannot generate instruction.");
+    process.exit(1);
+  }
+  try {
+    const debugLogger = createDebugLogger({
+      filePath: config.debugLogPath,
+      console: config.debugConsole
+    });
+    let reviewResult;
+    const reviewSpinner = spinner();
+    try {
+      const reviewStart = performance.now();
+      reviewSpinner.start(t("generator.aiReviewing"));
+      const { system: reviewSystem, userPrompt: reviewUserPrompt } = createReviewPrompt(config.goal, recordedSteps, goalAchieved, interventions);
+      debugLogger.log({
+        phase: "generator",
+        event: "ai_review",
+        data: { prompt: `${reviewSystem}
+---
+${reviewUserPrompt}`.slice(0, 500) }
+      });
+      const { object } = await trackedGenerateObject("review", {
+        model: getModel("review"),
+        messages: [
+          {
+            role: "system",
+            content: reviewSystem,
+            providerOptions: {
+              anthropic: { cacheControl: { type: "ephemeral" } }
+            }
+          },
+          { role: "user", content: reviewUserPrompt }
+        ],
+        schema: reviewResponseSchema,
+        temperature: 0
+      });
+      reviewResult = object;
+      debugLogger.log({
+        phase: "generator",
+        event: "ai_review",
+        data: {
+          parsedResult: reviewResult
+        }
+      });
+      const kept = reviewResult.reviewedSteps.filter((s) => s.keep).length;
+      const removed = reviewResult.reviewedSteps.filter((s) => !s.keep).length;
+      reviewSpinner.stop(`AI review done: ${kept} kept, ${removed} removed (${formatDuration(performance.now() - reviewStart)})`);
+      log.info(`Summary: ${reviewResult.summary}`);
+    } catch (error) {
+      reviewSpinner.stop(tf("generator.aiReviewFailed", { error: error instanceof Error ? error.message : String(error) }));
+      reviewResult = void 0;
+    }
+    let finalGuidance = additionalGuidance;
+    if (reviewResult) {
+      const edited = await promptReviewEdits(
+        reviewResult,
+        recordedSteps,
+        additionalGuidance
+      );
+      reviewResult = edited.reviewResult;
+      finalGuidance = edited.humanGuidance;
+    }
+    if (reviewResult) {
+      const keptWithConfirm = reviewResult.reviewedSteps.filter((s) => s.keep && s.requiresConfirmation).map((s) => `#${s.originalOrdinal}`);
+      log.info(`Confirmation required for steps: ${keptWithConfirm.join(", ") || t("common.none")}`);
+    }
+    const yamlStart = performance.now();
+    const yaml = buildInstructionYaml({
+      goal: config.goal,
+      startUrl: config.url,
+      recordedSteps,
+      goalAchieved,
+      stepDelay: config.stepDelay,
+      reviewResult,
+      humanGuidance: finalGuidance,
+      interventions
+    });
+    await mkdir2(dirname(config.output), { recursive: true });
+    await writeFile(config.output, yaml, "utf-8");
+    log.info(`YAML generation + write (${formatDuration(performance.now() - yamlStart)})`);
+    await debugLogger.flush();
+    log.success(`Instruction written to: ${config.output}`);
+    if (!goalAchieved) {
+      log.warn("Goal was NOT fully achieved. Instruction may be incomplete.");
+    }
+    const metrics = globalMetrics.getSummary();
+    if (metrics.totalCalls > 0) {
+      const purposeSummary = Object.entries(metrics.byPurpose).map(([p, b]) => `${p}(${b.calls})`).join(" ");
+      log.info(
+        `AI Metrics: ${metrics.totalCalls} calls, ${metrics.totalInputTokens.toLocaleString()} in / ${metrics.totalOutputTokens.toLocaleString()} out tokens, cache ${(metrics.cacheHitRate * 100).toFixed(1)}%, $${metrics.estimatedCostUsd.toFixed(4)}, ${(metrics.totalDurationMs / 1e3).toFixed(1)}s \u2014 ${purposeSummary}`
+      );
+      if (metrics.byModel && Object.keys(metrics.byModel).length > 1) {
+        const modelSummary = Object.entries(metrics.byModel).map(([id, b]) => `${id}($${b.estimatedCostUsd.toFixed(4)})`).join(" ");
+        log.info(`Models: ${modelSummary}`);
+      }
+    }
+    outro(`Total: ${formatDuration(performance.now() - totalStart)}`);
+  } catch (postExploreError) {
+    const errorMessage = postExploreError instanceof Error ? postExploreError.stack ?? postExploreError.message : String(postExploreError);
+    log.error(`Post-exploration phase failed: ${errorMessage}`);
+    const report = await generateExplorationReport({
+      goal: config.goal,
+      startUrl: config.url,
+      outcome: "error",
+      userFeedback: "",
+      recordedSteps,
+      interventions,
+      debugLogPath: config.debugLogPath,
+      errorMessage,
+      cliOptions,
+      aiMetrics: globalMetrics.getSummary(),
+      totalDurationMs: Math.round(performance.now() - totalStart)
+    });
+    const reportPath = config.output.replace(/\.\w+$/, "-report.md");
+    await mkdir2(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, report, "utf-8");
+    log.info(`Error report written to: ${reportPath}`);
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  cancel(`Fatal error: ${error instanceof Error ? error.message : String(error)}`);
+  process.exit(1);
+});
+//# sourceMappingURL=instruction-generator-5RPRYTVR.js.map