@basemachina/agentic-browser-cli 0.3.0

package/dist/chunk-U6GPCKY3.js

@@ -0,0 +1,3186 @@
+#!/usr/bin/env node
+import {
+  computeCacheRate,
+  computeTotalRealInput,
+  getModelId,
+  getModelProvider
+} from "./chunk-XAEHXRUC.js";
+import {
+  cancel,
+  getLocale,
+  log,
+  t
+} from "./chunk-VNQYQSMI.js";
+
+// src/cli/debug-logger.ts
+import { appendFile, writeFile } from "fs/promises";
+import * as p from "@clack/prompts";
+var FileDebugLogger = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.buffer = [];
+    this.writing = false;
+    this.pending = Promise.resolve();
+    this.initialized = false;
+  }
+  log(entry) {
+    const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
+    this.buffer.push(line);
+    this.scheduleWrite();
+  }
+  async flush() {
+    await this.pending;
+    if (this.buffer.length > 0) {
+      await this.writeBuffer();
+    }
+  }
+  scheduleWrite() {
+    if (this.writing) return;
+    this.pending = this.writeBuffer();
+  }
+  async writeBuffer() {
+    if (this.buffer.length === 0) return;
+    this.writing = true;
+    const lines = this.buffer.splice(0, this.buffer.length);
+    const content = lines.join("\n") + "\n";
+    try {
+      if (!this.initialized) {
+        await writeFile(this.filePath, content, "utf-8");
+        this.initialized = true;
+      } else {
+        await appendFile(this.filePath, content, "utf-8");
+      }
+    } catch {
+    }
+    this.writing = false;
+    if (this.buffer.length > 0) {
+      this.pending = this.writeBuffer();
+    }
+  }
+};
+var ConsoleDebugLogger = class {
+  log(entry) {
+    const stepPrefix = entry.step !== void 0 ? `step#${entry.step}` : "";
+    const prefix = `[debug] [${entry.event}]${stepPrefix ? ` ${stepPrefix}` : ""}`;
+    switch (entry.event) {
+      case "extract":
+      case "extract_result":
+        this.logExtract(prefix, entry.data);
+        break;
+      case "memory_append":
+        this.logMemoryAppend(prefix, entry.data);
+        break;
+      case "memory_aggregate":
+        this.logMemoryAggregate(prefix, entry.data);
+        break;
+      case "export":
+        this.logExport(prefix, entry.data);
+        break;
+      case "action":
+        this.logAction(prefix, entry.data);
+        break;
+      default:
+        this.logGeneric(prefix, entry.data);
+        break;
+    }
+  }
+  async flush() {
+  }
+  logExtract(prefix, data) {
+    if (data.script) {
+      p.log.info(`${prefix} script: "${truncate(String(data.script), 120)}"`);
+    }
+    if (data.extractPrompt) {
+      p.log.info(`${prefix} extractPrompt: "${truncate(String(data.extractPrompt), 120)}"`);
+    }
+    if (data.resultType !== void 0) {
+      const typeInfo = data.isArray ? `${data.resultType} (array), length: ${data.arrayLength}` : String(data.resultType);
+      p.log.info(`${prefix} result typeof: "${typeInfo}"`);
+    }
+    if (data.resultPreview !== void 0) {
+      p.log.info(`${prefix} result preview: ${truncate(String(data.resultPreview), 200)}`);
+    }
+    if (data.storedLength !== void 0) {
+      const note = data.stringifyApplied ? " \u2190 JSON.stringify applied" : "";
+      p.log.info(`${prefix} stored as string (length: ${data.storedLength})${note}`);
+    }
+  }
+  logMemoryAppend(prefix, data) {
+    if (data.collection) {
+      p.log.info(`${prefix} collection: "${data.collection}"`);
+    }
+    if (data.rawValuePreview !== void 0) {
+      p.log.info(`${prefix} rawValue preview (200 chars): ${truncate(String(data.rawValuePreview), 200)}`);
+    }
+    if (data.doubleStringifyDetected) {
+      p.log.warn(`${prefix} double-stringify detected! Unquoting before parse.`);
+    }
+    if (data.parseResult !== void 0) {
+      const result = data.parseResult;
+      if (result === "array") {
+        p.log.info(
+          `${prefix} JSON.parse OK \u2192 Array(${data.arrayLength}), element[0] keys: ${data.firstElementKeys ?? "N/A"}`
+        );
+      } else if (result === "object") {
+        p.log.info(`${prefix} JSON.parse OK \u2192 Object, keys: ${data.objectKeys ?? "N/A"}`);
+      } else if (result === "fallback") {
+        p.log.warn(`${prefix} JSON.parse FAILED \u2192 storing as {value: "..."}`);
+      }
+    }
+    if (data.count !== void 0 && data.parseResult === void 0) {
+      p.log.info(`${prefix} stored ${data.count} items`);
+    }
+  }
+  logMemoryAggregate(prefix, data) {
+    p.log.info(
+      `${prefix} ${data.operation}(${data.collection}.${data.field}) = "${data.result}" \u2192 {{${data.outputVariable}}}`
+    );
+  }
+  logExport(prefix, data) {
+    p.log.info(`${prefix} collection: "${data.collection}", items: ${data.itemCount}, format: ${data.format}`);
+    if (data.sampleKeys) {
+      p.log.info(`${prefix} sample keys: ${data.sampleKeys}`);
+    }
+    if (data.path) {
+      p.log.info(`${prefix} \u2192 ${data.path}`);
+    }
+  }
+  logAction(prefix, data) {
+    p.log.info(
+      `${prefix} type=${data.type} ref=${data.ref ?? "N/A"} value="${truncate(String(data.value ?? ""), 80)}" status=${data.status}`
+    );
+  }
+  logGeneric(prefix, data) {
+    const preview = JSON.stringify(data);
+    p.log.info(`${prefix} ${truncate(preview, 200)}`);
+  }
+};
+var CompositeDebugLogger = class {
+  constructor(loggers) {
+    this.loggers = loggers;
+  }
+  log(entry) {
+    for (const logger of this.loggers) {
+      logger.log(entry);
+    }
+  }
+  async flush() {
+    await Promise.all(this.loggers.map((l) => l.flush()));
+  }
+};
+var noopLogger = {
+  log() {
+  },
+  async flush() {
+  }
+};
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return `${str.slice(0, maxLen)}...`;
+}
+function createDebugLogger(opts) {
+  if (!opts) return noopLogger;
+  const loggers = [];
+  if (opts.filePath) {
+    loggers.push(new FileDebugLogger(opts.filePath));
+  }
+  if (opts.console) {
+    loggers.push(new ConsoleDebugLogger());
+  }
+  if (loggers.length === 0) return noopLogger;
+  if (loggers.length === 1) return loggers[0];
+  return new CompositeDebugLogger(loggers);
+}
+
+// src/context/data-store.ts
+import { writeFile as writeFile2 } from "fs/promises";
+var InMemoryDataStore = class {
+  constructor() {
+    this.collections = /* @__PURE__ */ new Map();
+  }
+  append(collection, item) {
+    const items = this.collections.get(collection) ?? [];
+    items.push(item);
+    this.collections.set(collection, items);
+  }
+  extend(collection, newItems) {
+    const items = this.collections.get(collection) ?? [];
+    items.push(...newItems);
+    this.collections.set(collection, items);
+  }
+  getAll(collection) {
+    return this.collections.get(collection) ?? [];
+  }
+  count(collection) {
+    return (this.collections.get(collection) ?? []).length;
+  }
+  clear(collection) {
+    this.collections.delete(collection);
+  }
+  listCollections() {
+    return Array.from(this.collections.keys());
+  }
+  toJSON() {
+    const result = {};
+    for (const [key, items] of this.collections) {
+      result[key] = items;
+    }
+    return result;
+  }
+  aggregate(query) {
+    const items = this.getAll(query.collection);
+    if (items.length === 0) return "0";
+    const values = items.map((item) => item[query.field]);
+    switch (query.operation) {
+      case "sum": {
+        const total = values.reduce(
+          (acc, v) => acc + (Number(v) || 0),
+          0
+        );
+        return String(total);
+      }
+      case "count":
+        return String(values.length);
+      case "concat":
+        return values.map(String).join(", ");
+      case "min": {
+        const nums = values.map(Number).filter((n) => !Number.isNaN(n));
+        return nums.length > 0 ? String(Math.min(...nums)) : "0";
+      }
+      case "max": {
+        const nums = values.map(Number).filter((n) => !Number.isNaN(n));
+        return nums.length > 0 ? String(Math.max(...nums)) : "0";
+      }
+      case "avg": {
+        const nums = values.map(Number).filter((n) => !Number.isNaN(n));
+        if (nums.length === 0) return "0";
+        const sum = nums.reduce((a, b) => a + b, 0);
+        return String(sum / nums.length);
+      }
+      case "unique_count": {
+        const unique = new Set(values.map(String));
+        return String(unique.size);
+      }
+    }
+  }
+  /**
+   * コレクションごとのメモリ圧迫状況を返す。
+   * low: <1000, medium: 1000-5000, high: >5000
+   */
+  getPressureStatus() {
+    const result = {};
+    for (const [name, items] of this.collections) {
+      const count = items.length;
+      const pressure = count >= 5e3 ? "high" : count >= 1e3 ? "medium" : "low";
+      result[name] = { count, pressure };
+    }
+    return result;
+  }
+  /** コレクションを CSV 文字列として出力 */
+  toCSV(collection) {
+    const items = this.getAll(collection);
+    if (items.length === 0) return "";
+    const keys = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      for (const key of Object.keys(item)) {
+        keys.add(key);
+      }
+    }
+    const headers = Array.from(keys);
+    const escapeCSV = (val) => {
+      const str = val === null || val === void 0 ? "" : String(val);
+      if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+        return `"${str.replace(/"/g, '""')}"`;
+      }
+      return str;
+    };
+    const rows = items.map(
+      (item) => headers.map((h) => escapeCSV(item[h])).join(",")
+    );
+    return [headers.join(","), ...rows].join("\n");
+  }
+  /** コレクションをファイルに書き出し */
+  async writeToFile(collection, path, format) {
+    const content = format === "csv" ? this.toCSV(collection) : JSON.stringify(this.getAll(collection), null, 2);
+    await writeFile2(path, content, "utf-8");
+  }
+};
+
+// src/context/download-manager.ts
+import { readFile, writeFile as writeFile3, mkdir, stat } from "fs/promises";
+import { join } from "path";
+import { randomUUID } from "crypto";
+var LocalStorage = class {
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  async write(filename, content) {
+    await mkdir(this.baseDir, { recursive: true });
+    const filePath = join(this.baseDir, filename);
+    await writeFile3(filePath, content);
+    return filePath;
+  }
+  async read(filename) {
+    const filePath = join(this.baseDir, filename);
+    return readFile(filePath);
+  }
+  async exists(filename) {
+    try {
+      await stat(join(this.baseDir, filename));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var DownloadManager = class {
+  constructor(outputDir) {
+    this.downloads = [];
+    this.storage = new LocalStorage(outputDir);
+  }
+  addDownload(record) {
+    const download = {
+      ...record,
+      id: randomUUID()
+    };
+    this.downloads.push(download);
+    return download;
+  }
+  getDownloads() {
+    return [...this.downloads];
+  }
+  getDownloadsByStep(stepOrdinal) {
+    return this.downloads.filter((d) => d.stepOrdinal === stepOrdinal);
+  }
+  /**
+   * 複数のダウンロード済みCSVファイルを結合する。
+   * 1つ目のファイルのヘッダを使用し、2つ目以降はヘッダ行をスキップ。
+   */
+  async mergeCSVFiles(downloadIds, outputFilename) {
+    const targets = downloadIds.map((id) => this.downloads.find((d) => d.id === id)).filter((d) => d !== void 0);
+    if (targets.length === 0) {
+      throw new Error("No downloads found for the given IDs");
+    }
+    const chunks = [];
+    let headerLine = null;
+    for (let i = 0; i < targets.length; i++) {
+      const content = await readFile(targets[i].path, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim().length > 0);
+      if (lines.length === 0) continue;
+      if (i === 0) {
+        headerLine = lines[0];
+        chunks.push(content.trimEnd());
+      } else {
+        const dataLines = lines.slice(1);
+        if (dataLines.length > 0) {
+          chunks.push(dataLines.join("\n"));
+        }
+      }
+    }
+    const merged = chunks.join("\n") + "\n";
+    const outputPath = await this.storage.write(outputFilename, merged);
+    return outputPath;
+  }
+  /** 全ダウンロードの ID 一覧 */
+  getAllDownloadIds() {
+    return this.downloads.map((d) => d.id);
+  }
+  /** ダウンロードのファイルパス一覧 */
+  getAllPaths() {
+    return this.downloads.map((d) => d.path);
+  }
+};
+
+// src/cli/format.ts
+function formatDuration(ms) {
+  return ms >= 1e3 ? `${(ms / 1e3).toFixed(1)}s` : `${Math.round(ms)}ms`;
+}
+
+// src/cli/options-serializer.ts
+function serializeGeneratorOptions(config) {
+  const opts = [];
+  opts.push({ name: "--url", value: config.url });
+  opts.push({ name: "--goal", value: config.goal });
+  opts.push({ name: "--output", value: config.output });
+  opts.push({ name: "--headless", value: String(config.headless) });
+  opts.push({ name: "--max-iterations", value: String(config.maxIterations) });
+  opts.push({ name: "--step-delay", value: `${config.stepDelay}ms` });
+  opts.push({ name: "--stall-check-interval", value: String(config.stallCheckInterval) });
+  opts.push({ name: "--history-window", value: String(config.historyWindow) });
+  opts.push({ name: "--max-failures", value: String(config.maxConsecutiveFailures) });
+  opts.push({ name: "--snapshot-filter", value: String(config.snapshotFilter) });
+  if (config.screenshotDir) {
+    opts.push({ name: "--screenshots", value: config.screenshotDir });
+  }
+  if (config.contextMarkdown) {
+    opts.push({ name: "--context", value: `loaded (${config.contextMarkdown.split("\n").length} lines)` });
+  }
+  if (config.secrets && Object.keys(config.secrets.values).length > 0) {
+    opts.push({ name: "--secrets", value: `${Object.keys(config.secrets.values).length} keys` });
+  }
+  if (config.debugLogPath) {
+    opts.push({ name: "--debug-log", value: config.debugLogPath });
+  }
+  if (config.debugConsole) {
+    opts.push({ name: "--debug", value: "true" });
+  }
+  if (config.stealth) {
+    opts.push({ name: "--stealth", value: "true" });
+  }
+  if (config.proxy) {
+    opts.push({ name: "--proxy", value: config.proxy });
+  }
+  if (config.videoDir) {
+    opts.push({ name: "--video", value: config.videoDir });
+  }
+  serializeModelConfig(opts, config.aiModelConfig);
+  return opts;
+}
+function serializeExecutorOptions(config) {
+  const opts = [];
+  opts.push({ name: "--instruction", value: config.instructionPath });
+  opts.push({ name: "--headless", value: String(config.headless) });
+  if (config.stepDelay !== void 0) {
+    opts.push({ name: "--step-delay", value: `${config.stepDelay}ms` });
+  }
+  if (config.screenshotDir) {
+    opts.push({ name: "--screenshots", value: config.screenshotDir });
+  }
+  if (config.contextMarkdown) {
+    opts.push({ name: "--context", value: `loaded (${config.contextMarkdown.split("\n").length} lines)` });
+  }
+  if (config.secrets && Object.keys(config.secrets.values).length > 0) {
+    opts.push({ name: "--secrets", value: `${Object.keys(config.secrets.values).length} keys` });
+  }
+  if (config.skipConfirmation) {
+    opts.push({ name: "--skip-confirmation", value: "true" });
+  }
+  if (config.dataFilePath) {
+    opts.push({ name: "--data", value: config.dataFilePath });
+  }
+  if (config.reuseSession === false) {
+    opts.push({ name: "--no-reuse-session", value: "true" });
+  }
+  if (config.debugLogPath) {
+    opts.push({ name: "--debug-log", value: config.debugLogPath });
+  }
+  if (config.debugConsole) {
+    opts.push({ name: "--debug", value: "true" });
+  }
+  if (config.approvalMode && config.approvalMode !== "cli") {
+    opts.push({ name: "--approval-mode", value: config.approvalMode });
+  }
+  if (config.notifyMode) {
+    opts.push({ name: "--notify", value: config.notifyMode });
+  }
+  if (config.enableSelectorCache) {
+    opts.push({ name: "--enable-selector-cache", value: "true" });
+  }
+  if (config.enableAgentFallback) {
+    opts.push({ name: "--enable-agent-fallback", value: "true" });
+  }
+  if (config.enableVisionFallback) {
+    opts.push({ name: "--enable-vision-fallback", value: "true" });
+  }
+  if (config.outputDir) {
+    opts.push({ name: "--output-dir", value: config.outputDir });
+  }
+  if (config.mergeDownloads) {
+    opts.push({ name: "--merge-downloads", value: "true" });
+  }
+  if (config.maintenance) {
+    opts.push({ name: "--maintenance", value: "true" });
+  }
+  if (config.maxRetries !== void 0) {
+    opts.push({ name: "--max-retries", value: String(config.maxRetries) });
+  }
+  if (config.retryWarningThreshold !== void 0) {
+    opts.push({ name: "--retry-warning-threshold", value: String(config.retryWarningThreshold) });
+  }
+  if (config.forceReport) {
+    opts.push({ name: "--report", value: "true" });
+  }
+  if (config.videoDir) {
+    opts.push({ name: "--video", value: config.videoDir });
+  }
+  if (config.callbackPort !== void 0) {
+    opts.push({ name: "--callback-port", value: String(config.callbackPort) });
+  }
+  if (config.approvalTimeoutMs !== void 0) {
+    opts.push({ name: "--approval-timeout", value: `${config.approvalTimeoutMs}ms` });
+  }
+  if (config.stealth) {
+    opts.push({ name: "--stealth", value: "true" });
+  }
+  if (config.proxy) {
+    opts.push({ name: "--proxy", value: config.proxy });
+  }
+  serializeModelConfig(opts, config.aiModelConfig);
+  return opts;
+}
+var MODEL_OVERRIDE_FLAGS = {
+  selector: "--model-selector",
+  extraction: "--model-extraction",
+  exploration: "--model-exploration",
+  review: "--model-review",
+  fallback: "--model-fallback",
+  vision: "--model-vision"
+};
+function serializeModelConfig(opts, aiModelConfig) {
+  if (!aiModelConfig) return;
+  opts.push({ name: "--model", value: aiModelConfig.modelId });
+  opts.push({ name: "--model-provider", value: aiModelConfig.provider });
+  if (aiModelConfig.baseURL) {
+    opts.push({ name: "--model-base-url", value: aiModelConfig.baseURL });
+  }
+  if (aiModelConfig.modelOverrides) {
+    for (const [purpose, modelId] of Object.entries(aiModelConfig.modelOverrides)) {
+      const flag = MODEL_OVERRIDE_FLAGS[purpose];
+      if (flag && modelId) {
+        opts.push({ name: flag, value: modelId });
+      }
+    }
+  }
+}
+function renderOptionsMarkdown(options) {
+  if (options.length === 0) return [];
+  const lines = [];
+  for (const opt of options) {
+    lines.push(`- \`${opt.name}\`: ${opt.value}`);
+  }
+  return lines;
+}
+
+// src/cli/secrets-loader.ts
+import { readFile as readFile2 } from "fs/promises";
+async function loadSecrets(path) {
+  if (!path) {
+    return { values: {}, keys: /* @__PURE__ */ new Set() };
+  }
+  const raw = await readFile2(path, "utf-8").catch(() => {
+    cancel(`secrets \u30D5\u30A1\u30A4\u30EB\u304C\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093: ${path}`);
+    process.exit(1);
+  });
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    cancel(`secrets \u30D5\u30A1\u30A4\u30EB\u306E JSON \u30D1\u30FC\u30B9\u306B\u5931\u6557\u3057\u307E\u3057\u305F: ${path}`);
+    process.exit(1);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    cancel('secrets \u30D5\u30A1\u30A4\u30EB\u306F\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u5F62\u5F0F {"key": "value"} \u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059');
+    process.exit(1);
+  }
+  const values = {};
+  for (const [key, val] of Object.entries(parsed)) {
+    if (typeof val !== "string") {
+      cancel(`secrets \u306E\u5024\u306F\u6587\u5B57\u5217\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059 (key: "${key}")`);
+      process.exit(1);
+    }
+    values[key] = val;
+  }
+  return {
+    values,
+    keys: new Set(Object.keys(values))
+  };
+}
+
+// src/logger.ts
+var NoopLogger = class {
+  step(_message) {
+  }
+  success(_message) {
+  }
+  error(_message) {
+  }
+  warn(_message) {
+  }
+  info(_message) {
+  }
+  debug(_message) {
+  }
+};
+var NoopSpinner = class {
+  start(_message) {
+  }
+  stop(_message) {
+  }
+};
+
+// src/browser/browser-client.ts
+import { mkdir as mkdir2, readFile as readFile3, unlink } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { spawn, execSync } from "child_process";
+
+// src/browser/agent-browser-imports.ts
+import { BrowserManager } from "agent-browser/dist/browser.js";
+import { executeCommand } from "agent-browser/dist/actions.js";
+import { resetRefs, getSnapshotStats } from "agent-browser/dist/snapshot.js";
+
+// src/browser/stealth.ts
+function webdriverPatch() {
+  return `
+    Object.defineProperty(navigator, 'webdriver', {
+      get: () => undefined,
+    });
+  `;
+}
+function chromePatch() {
+  return `
+    if (!window.chrome) {
+      Object.defineProperty(window, 'chrome', {
+        writable: true,
+        enumerable: true,
+        configurable: true,
+        value: {},
+      });
+    }
+    if (!window.chrome.runtime) {
+      window.chrome.runtime = {
+        connect: function() { return { onMessage: { addListener: function() {} }, postMessage: function() {}, onDisconnect: { addListener: function() {} } }; },
+        sendMessage: function(a, b, c) { if (typeof c === 'function') c(); },
+      };
+    }
+  `;
+}
+function pluginsPatch() {
+  return `
+    Object.defineProperty(navigator, 'plugins', {
+      get: () => {
+        const plugins = [
+          { name: 'Chrome PDF Plugin', filename: 'internal-pdf-viewer', description: 'Portable Document Format' },
+          { name: 'Chrome PDF Viewer', filename: 'mhjfbmdgcfjbbpaeojofohoefgiehjai', description: '' },
+          { name: 'Native Client', filename: 'internal-nacl-plugin', description: '' },
+        ];
+        plugins.refresh = () => {};
+        return plugins;
+      },
+    });
+    Object.defineProperty(navigator, 'mimeTypes', {
+      get: () => {
+        const mimeTypes = [
+          { type: 'application/pdf', suffixes: 'pdf', description: 'Portable Document Format' },
+          { type: 'application/x-google-chrome-pdf', suffixes: 'pdf', description: 'Portable Document Format' },
+        ];
+        mimeTypes.refresh = () => {};
+        return mimeTypes;
+      },
+    });
+  `;
+}
+function languagesPatch() {
+  return `
+    Object.defineProperty(navigator, 'languages', {
+      get: () => ['en-US', 'en'],
+    });
+  `;
+}
+function permissionsPatch() {
+  return `
+    const originalQuery = navigator.permissions.query.bind(navigator.permissions);
+    navigator.permissions.query = (parameters) => {
+      if (parameters.name === 'notifications') {
+        return Promise.resolve({ state: Notification.permission });
+      }
+      return originalQuery(parameters);
+    };
+  `;
+}
+function webglPatch() {
+  return `
+    const getParameter = WebGLRenderingContext.prototype.getParameter;
+    WebGLRenderingContext.prototype.getParameter = function(parameter) {
+      // UNMASKED_VENDOR_WEBGL
+      if (parameter === 37445) return 'Google Inc. (Intel)';
+      // UNMASKED_RENDERER_WEBGL
+      if (parameter === 37446) return 'ANGLE (Intel, Intel(R) UHD Graphics, OpenGL 4.1)';
+      return getParameter.call(this, parameter);
+    };
+    if (typeof WebGL2RenderingContext !== 'undefined') {
+      const getParameter2 = WebGL2RenderingContext.prototype.getParameter;
+      WebGL2RenderingContext.prototype.getParameter = function(parameter) {
+        if (parameter === 37445) return 'Google Inc. (Intel)';
+        if (parameter === 37446) return 'ANGLE (Intel, Intel(R) UHD Graphics, OpenGL 4.1)';
+        return getParameter2.call(this, parameter);
+      };
+    }
+  `;
+}
+function hardwareConcurrencyPatch() {
+  return `
+    Object.defineProperty(navigator, 'hardwareConcurrency', {
+      get: () => 4,
+    });
+  `;
+}
+function iframePatch() {
+  return `
+    try {
+      if (window.self !== window.top) return;
+      const originalAttachShadow = Element.prototype.attachShadow;
+      if (originalAttachShadow) {
+        Element.prototype.attachShadow = function() {
+          return originalAttachShadow.call(this, ...arguments);
+        };
+      }
+    } catch {}
+  `;
+}
+function userAgentPatch() {
+  return `
+    (function() {
+      var ua = navigator.userAgent || '';
+      if (ua.indexOf('HeadlessChrome') !== -1) {
+        var cleanUA = ua.replace('HeadlessChrome', 'Chrome');
+        Object.defineProperty(navigator, 'userAgent', {
+          get: () => cleanUA,
+        });
+      }
+      var av = navigator.appVersion || '';
+      if (av.indexOf('HeadlessChrome') !== -1) {
+        var cleanAV = av.replace('HeadlessChrome', 'Chrome');
+        Object.defineProperty(navigator, 'appVersion', {
+          get: () => cleanAV,
+        });
+      }
+    })();
+  `;
+}
+function getStealthScripts() {
+  return [
+    webdriverPatch(),
+    chromePatch(),
+    pluginsPatch(),
+    languagesPatch(),
+    permissionsPatch(),
+    webglPatch(),
+    hardwareConcurrencyPatch(),
+    iframePatch(),
+    userAgentPatch()
+  ];
+}
+async function applyStealthScripts(page) {
+  const context = page.context();
+  const scripts = getStealthScripts();
+  for (const script of scripts) {
+    await context.addInitScript(script);
+  }
+}
+
+// src/browser/browser-client.ts
+function parseProxyUrl(proxyUrl) {
+  try {
+    const url = new URL(proxyUrl);
+    const server = `${url.protocol}//${url.hostname}${url.port ? `:${url.port}` : ""}`;
+    const username = url.username || void 0;
+    const password = url.password || void 0;
+    return { server, username, password };
+  } catch {
+    return { server: proxyUrl };
+  }
+}
+var commandId = 0;
+function nextId() {
+  return String(++commandId);
+}
+var SCREENCAST_FPS = 5;
+var FRAME_PUMP_INTERVAL_MS = Math.round(1e3 / SCREENCAST_FPS);
+var SCREENCAST_RECOVERY_INTERVAL_MS = 500;
+var AgentBrowser = class {
+  constructor(logger) {
+    this.browser = new BrowserManager();
+    // CDP Screencast + ffmpeg 録画用プロパティ
+    this.ffmpegProcess = null;
+    this.latestFrame = null;
+    this.framePumpInterval = null;
+    this.screencastRecoveryInterval = null;
+    this.isScreencastRecording = false;
+    this.screencastOutputPath = null;
+    this.logger = logger ?? new NoopLogger();
+  }
+  /**
+   * executeCommand のラッパー。失敗時はthrow。
+   */
+  async exec(command) {
+    const response = await executeCommand(command, this.browser);
+    if (!response.success) {
+      throw new Error(response.error);
+    }
+    return response;
+  }
+  async open(url, options) {
+    if (!this.browser.isLaunched()) {
+      const launchCommand = {
+        id: nextId(),
+        action: "launch",
+        headless: options?.headless ?? true,
+        viewport: { width: 1280, height: 720 },
+        colorScheme: options?.colorScheme,
+        downloadPath: options?.downloadPath,
+        proxy: options?.proxy ? parseProxyUrl(options.proxy) : void 0
+      };
+      await this.browser.launch(launchCommand);
+      if (options?.stealth) {
+        await applyStealthScripts(this.browser.getPage());
+        this.logger.debug("[stealth] patches applied");
+      }
+    }
+    await this.exec({ id: nextId(), action: "navigate", url });
+  }
+  async snapshot(options) {
+    const result = await this.browser.getSnapshot({ compact: true, cursor: true, ...options });
+    return result.tree;
+  }
+  async snapshotWithRefs(options) {
+    const result = await this.browser.getSnapshot({ compact: true, cursor: true, ...options });
+    return { tree: result.tree, refs: result.refs };
+  }
+  async click(ref) {
+    await this.exec({ id: nextId(), action: "click", selector: ref });
+  }
+  async fill(ref, value) {
+    await this.exec({ id: nextId(), action: "fill", selector: ref, value });
+  }
+  async type(ref, text) {
+    await this.exec({
+      id: nextId(),
+      action: "type",
+      selector: ref,
+      text
+    });
+  }
+  async select(ref, value) {
+    await this.exec({
+      id: nextId(),
+      action: "select",
+      selector: ref,
+      values: value
+    });
+  }
+  async check(ref) {
+    await this.exec({ id: nextId(), action: "check", selector: ref });
+  }
+  async uncheck(ref) {
+    await this.exec({ id: nextId(), action: "uncheck", selector: ref });
+  }
+  async navigate(url) {
+    await this.exec({ id: nextId(), action: "navigate", url });
+  }
+  async wait(ms) {
+    await this.exec({ id: nextId(), action: "wait", timeout: ms });
+  }
+  async scroll(direction, amount = 500, options) {
+    await this.exec({
+      id: nextId(),
+      action: "scroll",
+      direction,
+      amount,
+      selector: options?.selector
+    });
+  }
+  async screenshot(path, options) {
+    const response = await this.exec({
+      id: nextId(),
+      action: "screenshot",
+      path,
+      ...options
+    });
+    const data = response.data;
+    return data?.annotations ?? [];
+  }
+  /**
+   * アノテーション付きスクリーンショットを撮影し、画像バッファとアノテーション配列を返す。
+   * Vision Fallback 用: AI にスクリーンショットを渡して視覚的にセレクタを解決する。
+   */
+  async screenshotWithAnnotations() {
+    const tempPath = join2(tmpdir(), `vision-fallback-${Date.now()}.png`);
+    const annotations = await this.screenshot(tempPath, { annotate: true });
+    const imageBuffer = await readFile3(tempPath);
+    unlink(tempPath).catch(() => {
+    });
+    return { imageBuffer, annotations };
+  }
+  async download(selector, savePath) {
+    await this.exec({
+      id: nextId(),
+      action: "download",
+      selector,
+      path: savePath
+    });
+    return savePath;
+  }
+  async waitForDownload(savePath, timeout) {
+    await this.exec({
+      id: nextId(),
+      action: "waitfordownload",
+      path: savePath,
+      timeout: timeout ?? 3e4
+    });
+  }
+  async evaluate(script) {
+    const response = await this.exec({
+      id: nextId(),
+      action: "evaluate",
+      script
+    });
+    const data = response.data;
+    return data?.result ?? data;
+  }
+  async getText(selector) {
+    const response = await this.exec({
+      id: nextId(),
+      action: "gettext",
+      selector
+    });
+    const data = response.data;
+    return String(data ?? "");
+  }
+  async getInnerText(selector) {
+    const response = await this.exec({
+      id: nextId(),
+      action: "innertext",
+      selector
+    });
+    const data = response.data;
+    return String(data ?? "");
+  }
+  async url() {
+    return this.browser.getPage().url();
+  }
+  /** アクション前のページ数を返す */
+  async pageCount() {
+    return this.browser.getPages().length;
+  }
+  /**
+   * 新しいタブが開かれた場合、最新のタブに切り替える。
+   * @returns 切り替えが発生したかどうか
+   */
+  async switchToLatestTab(pageCountBefore) {
+    const pages = this.browser.getPages();
+    if (pages.length > pageCountBefore) {
+      const latestIndex = pages.length - 1;
+      await this.browser.switchTo(latestIndex);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * DOM が安定するまで待機（SPA遷移後のレンダリング完了検出用）。
+   * Phase 1: networkidle を最大3秒待つ
+   * Phase 2: スナップショットをアダプティブ間隔でポーリングし、
+   *          2回連続で同一なら安定と判定。
+   *          初期100ms → 200ms → 300ms と段階的に延長（高速ページで早期検出）
+   */
+  async waitForDOMStability(timeoutMs = 5e3) {
+    const page = this.browser.getPage();
+    try {
+      await page.waitForLoadState("networkidle", { timeout: Math.min(timeoutMs, 3e3) });
+    } catch {
+    }
+    const pollEnd = Date.now() + timeoutMs;
+    let prevSnapshot = "";
+    let stableCount = 0;
+    let pollCount = 0;
+    while (Date.now() < pollEnd) {
+      const current = await this.snapshot();
+      if (current === prevSnapshot) {
+        stableCount++;
+        if (stableCount >= 2) {
+          this.logger.debug("[dom-stability] snapshot stable");
+          return;
+        }
+      } else {
+        stableCount = 0;
+      }
+      prevSnapshot = current;
+      pollCount++;
+      const interval = pollCount <= 1 ? 100 : pollCount <= 2 ? 200 : 300;
+      await new Promise((r) => setTimeout(r, interval));
+    }
+    this.logger.debug("[dom-stability] timeout, proceeding");
+  }
+  /**
+   * スナップショットが変化するまでポーリングで待機。
+   * SPA遷移がまだ始まっていないケースに対応。
+   * waitForDOMStability（変化が止まるのを待つ）とは逆で、変化が始まるのを待つ。
+   */
+  async waitForSnapshotChange(baselineSnapshot, timeoutMs = 1e4, pollIntervalMs = 500) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, pollIntervalMs));
+      const current = await this.snapshot();
+      if (current !== baselineSnapshot) {
+        this.logger.debug("[snapshot-change] transition detected");
+        await this.waitForDOMStability();
+        return { changed: true, snapshot: await this.snapshot() };
+      }
+    }
+    this.logger.debug("[snapshot-change] timeout, no change");
+    return { changed: false, snapshot: baselineSnapshot };
+  }
+  /**
+   * アクション後のナビゲーション/タブ切替を待機。
+   * Stage 1: 新タブが開いていたら切り替え + ロード待機
+   * Stage 2: 同一タブ内のナビゲーションなら URL 変化を待機
+   * Stage 3: URL変化なしの場合、スナップショット変化でSPA遷移を検知し安定化待機
+   */
+  async waitForPossibleNavigation(urlBefore, pageCountBefore, timeout = 3e3) {
+    const pollEnd = Date.now() + 500;
+    let switched = false;
+    while (Date.now() < pollEnd) {
+      const currentCount = this.browser.getPages().length;
+      this.logger.debug(`[nav] polling tabs: before=${pageCountBefore} now=${currentCount}`);
+      if (currentCount > pageCountBefore) {
+        switched = true;
+        break;
+      }
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    if (switched) {
+      const pages = this.browser.getPages();
+      const latestIndex = pages.length - 1;
+      this.logger.debug(`[nav] new tab detected, switching to index ${latestIndex}`);
+      await this.browser.switchTo(latestIndex);
+      const page2 = this.browser.getPage();
+      this.logger.debug(`[nav] switched, url=${page2.url()}`);
+      try {
+        await page2.waitForLoadState("load", { timeout });
+      } catch {
+      }
+      this.logger.debug(`[nav] load complete, url=${page2.url()}`);
+      return;
+    }
+    this.logger.debug(`[nav] no new tab, checking same-tab navigation (urlBefore=${urlBefore})`);
+    const page = this.browser.getPage();
+    let urlChanged = false;
+    try {
+      await page.waitForURL(
+        (url) => url.toString() !== urlBefore,
+        { timeout, waitUntil: "load" }
+      );
+      urlChanged = true;
+      this.logger.debug(`[nav] URL changed to ${page.url()}`);
+      await this.waitForDOMStability();
+    } catch {
+      this.logger.debug(`[nav] no URL change detected`);
+    }
+    if (!urlChanged) {
+      this.logger.debug("[nav] checking SPA transition via snapshot diff");
+      const snapshotBefore = await this.snapshot();
+      const spaPollEnd = Date.now() + 5e3;
+      const stageStart = Date.now();
+      let spaDetected = false;
+      let stableCount = 0;
+      while (Date.now() < spaPollEnd) {
+        await new Promise((r) => setTimeout(r, 300));
+        const current = await this.snapshot();
+        if (current !== snapshotBefore) {
+          spaDetected = true;
+          this.logger.debug("[nav] SPA transition detected (snapshot changed)");
+          break;
+        }
+        stableCount++;
+        if (Date.now() - stageStart >= 1e3 && stableCount >= 3) {
+          this.logger.debug("[nav] snapshot stable, no SPA transition");
+          break;
+        }
+      }
+      if (spaDetected) {
+        await this.waitForDOMStability();
+      }
+    }
+  }
+  /**
+   * CDP Screencast + ffmpeg でビューポート全体を録画開始する。
+   * タブ切り替えを含む単一動画を生成する。
+   * @param outputDir 動画ファイル保存先ディレクトリ
+   * @param _url 未使用（後方互換性のため残す）
+   */
+  async startRecording(outputDir, _url) {
+    if (this.isScreencastRecording) {
+      return;
+    }
+    try {
+      execSync("which ffmpeg", { stdio: "ignore" });
+    } catch {
+      this.logger.warn(
+        "ffmpeg \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002--video \u3092\u4F7F\u7528\u3059\u308B\u306B\u306F ffmpeg \u3092\u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3057\u3066\u304F\u3060\u3055\u3044"
+      );
+      return;
+    }
+    await mkdir2(outputDir, { recursive: true });
+    const now = /* @__PURE__ */ new Date();
+    const pad = (n) => String(n).padStart(2, "0");
+    const ts = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}T${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+    const outputPath = join2(outputDir, `recording-${ts}.webm`);
+    this.screencastOutputPath = outputPath;
+    this.ffmpegProcess = spawn("ffmpeg", [
+      "-f",
+      "image2pipe",
+      "-framerate",
+      String(SCREENCAST_FPS),
+      "-vcodec",
+      "mjpeg",
+      "-i",
+      "pipe:0",
+      "-c:v",
+      "libvpx",
+      "-b:v",
+      "1M",
+      "-auto-alt-ref",
+      "0",
+      "-y",
+      outputPath
+    ], { stdio: ["pipe", "ignore", "ignore"] });
+    this.ffmpegProcess.on("error", (err) => {
+      this.logger.warn(`ffmpeg \u30D7\u30ED\u30BB\u30B9\u30A8\u30E9\u30FC: ${err.message}`);
+    });
+    this.latestFrame = null;
+    const frameCallback = (frame) => {
+      this.latestFrame = Buffer.from(frame.data, "base64");
+    };
+    try {
+      await this.browser.startScreencast(frameCallback, {
+        format: "jpeg",
+        quality: 80
+      });
+    } catch (err) {
+      this.logger.warn(
+        `screencast \u958B\u59CB\u306B\u5931\u6557: ${err instanceof Error ? err.message : String(err)}`
+      );
+      this.cleanupFfmpeg();
+      return;
+    }
+    this.isScreencastRecording = true;
+    this.framePumpInterval = setInterval(() => {
+      if (this.latestFrame && this.ffmpegProcess?.stdin?.writable) {
+        try {
+          this.ffmpegProcess.stdin.write(this.latestFrame);
+        } catch {
+        }
+      }
+    }, FRAME_PUMP_INTERVAL_MS);
+    this.screencastRecoveryInterval = setInterval(async () => {
+      if (!this.isScreencastRecording) return;
+      try {
+        if (!this.browser.isScreencasting()) {
+          this.logger.debug("[screencast] \u56DE\u5FA9: screencast \u3092\u518D\u958B");
+          await this.browser.startScreencast(frameCallback, {
+            format: "jpeg",
+            quality: 80
+          });
+        }
+      } catch {
+      }
+    }, SCREENCAST_RECOVERY_INTERVAL_MS);
+  }
+  /**
+   * ffmpeg プロセスをクリーンアップする内部ヘルパー。
+   */
+  cleanupFfmpeg() {
+    if (this.ffmpegProcess) {
+      try {
+        this.ffmpegProcess.stdin?.end();
+        this.ffmpegProcess.kill();
+      } catch {
+      }
+      this.ffmpegProcess = null;
+    }
+    this.screencastOutputPath = null;
+  }
+  /**
+   * 録画を停止し、動画ファイルパスを返す。
+   * @returns paths: 保存された動画ファイルパス一覧, frames: 0（CDP screencast ではフレーム数不明）
+   */
+  async stopRecording() {
+    if (!this.isScreencastRecording) {
+      return { paths: [], frames: 0, error: "No recording in progress" };
+    }
+    if (this.framePumpInterval) {
+      clearInterval(this.framePumpInterval);
+      this.framePumpInterval = null;
+    }
+    if (this.screencastRecoveryInterval) {
+      clearInterval(this.screencastRecoveryInterval);
+      this.screencastRecoveryInterval = null;
+    }
+    try {
+      await this.browser.stopScreencast();
+    } catch {
+    }
+    const outputPath = this.screencastOutputPath;
+    this.isScreencastRecording = false;
+    this.latestFrame = null;
+    if (this.ffmpegProcess) {
+      const ffmpeg = this.ffmpegProcess;
+      this.ffmpegProcess = null;
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          ffmpeg.kill("SIGKILL");
+          resolve();
+        }, 1e4);
+        ffmpeg.on("close", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+        try {
+          ffmpeg.stdin?.end();
+        } catch {
+          clearTimeout(timeout);
+          resolve();
+        }
+      });
+    }
+    this.screencastOutputPath = null;
+    if (outputPath) {
+      return { paths: [outputPath], frames: 0 };
+    }
+    return { paths: [], frames: 0 };
+  }
+  /**
+   * 現在録画中かどうかを返す。
+   */
+  isRecording() {
+    return this.isScreencastRecording;
+  }
+  async close() {
+    if (this.isScreencastRecording) {
+      try {
+        await this.stopRecording();
+      } catch {
+      }
+    }
+    this.cleanupFfmpeg();
+    await this.browser.close();
+  }
+  /**
+   * ExplorationAction を適切なコマンドにディスパッチ
+   */
+  async executeStep(step) {
+    const start = Date.now();
+    try {
+      let output = "";
+      switch (step.action) {
+        case "click":
+          await this.click(step.selector);
+          break;
+        case "fill":
+          await this.fill(step.selector, step.value || "");
+          break;
+        case "type":
+          await this.type(step.selector, step.value || "");
+          break;
+        case "select":
+          await this.select(step.selector, step.value || "");
+          break;
+        case "check":
+          await this.check(step.selector);
+          break;
+        case "uncheck":
+          await this.uncheck(step.selector);
+          break;
+        case "navigate":
+          await this.navigate(step.value);
+          break;
+        case "wait":
+          await this.wait(Number(step.value) || 1e3);
+          break;
+        case "scroll":
+          await this.scroll(step.value || "down");
+          break;
+        case "extract": {
+          const script = step.value || step.script || "";
+          if (script) {
+            const result = await this.evaluate(script);
+            output = typeof result === "string" ? result : JSON.stringify(result);
+          }
+          break;
+        }
+        case "download": {
+          const downloadPath = step.downloadPath || `/tmp/download-${Date.now()}.bin`;
+          await this.download(step.selector, downloadPath);
+          output = downloadPath;
+          break;
+        }
+        default:
+          output = `Unknown action: ${step.action}`;
+      }
+      return {
+        success: true,
+        output,
+        durationMs: Date.now() - start
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        durationMs: Date.now() - start
+      };
+    }
+  }
+};
+
+// src/browser/snapshot-parser.ts
+function parseSnapshotLine(line) {
+  const refMatch = line.match(/\[ref=(e\d+)\]/);
+  if (!refMatch) return null;
+  const ref = refMatch[1];
+  const refIndex = line.indexOf(refMatch[0]);
+  const beforeRef = line.slice(0, refIndex).trim();
+  const afterRef = line.slice(refIndex + refMatch[0].length).trim();
+  const cleanBefore = beforeRef.replace(/^-\s+/, "");
+  let role;
+  let name;
+  const roleNameMatch = cleanBefore.match(/^(\S+)\s+"([^"]*)"$/);
+  const roleOnlyMatch = cleanBefore.match(/^(\S+)$/);
+  if (roleNameMatch) {
+    role = roleNameMatch[1];
+    name = roleNameMatch[2];
+  } else if (roleOnlyMatch && !roleOnlyMatch[1].startsWith("[")) {
+    role = roleOnlyMatch[1];
+    name = "";
+  } else {
+    return null;
+  }
+  const attrSource = afterRef.replace(/:$/, "").trim();
+  const attributes = {};
+  const attrRegex = /\[(\w+)(?:=([^\]]*))?\]/g;
+  let attrMatch;
+  while ((attrMatch = attrRegex.exec(attrSource)) !== null) {
+    const key = attrMatch[1];
+    if (key === "ref") continue;
+    const value = attrMatch[2] ?? "true";
+    attributes[key] = value;
+  }
+  return { ref, role, name, attributes };
+}
+function findElementInSnapshot(snapshot, ref) {
+  const lines = snapshot.split("\n");
+  for (const line of lines) {
+    if (!line.includes(`[ref=${ref}]`)) continue;
+    const parsed = parseSnapshotLine(line);
+    if (parsed && parsed.ref === ref) return parsed;
+  }
+  return null;
+}
+function parseAllElements(snapshot) {
+  const lines = snapshot.split("\n");
+  const elements = [];
+  for (const line of lines) {
+    const parsed = parseSnapshotLine(line);
+    if (parsed) elements.push(parsed);
+  }
+  return elements;
+}
+function countElements(snapshot) {
+  return parseAllElements(snapshot).length;
+}
+
+// src/harness/error-classifier.ts
+function classifyFailure(ctx) {
+  if (ctx.actionExecuted) {
+    return "action_failed";
+  }
+  if (ctx.cachedRefUsed && !ctx.selectorResolved) {
+    return "element_stale";
+  }
+  if (!ctx.selectorResolved && ctx.retryDetails && ctx.retryDetails.length > 0) {
+    const anySnapshotChange = ctx.retryDetails.some((d) => d.snapshotChanged);
+    if (anySnapshotChange) {
+      return "page_structure_changed";
+    }
+    return "element_not_found";
+  }
+  if (!ctx.selectorResolved) {
+    return "element_not_found";
+  }
+  const lowerError = ctx.error.toLowerCase();
+  if (lowerError.includes("timeout") || lowerError.includes("navigation")) {
+    return "navigation_timeout";
+  }
+  return "unknown";
+}
+function getRecoveryHint(category) {
+  const keyMap = {
+    element_not_found: "errors.elementNotFound",
+    element_stale: "errors.elementStale",
+    page_structure_changed: "errors.pageStructureChanged",
+    navigation_timeout: "errors.navigationTimeout",
+    action_failed: "errors.actionFailed",
+    unknown: "errors.unknownError"
+  };
+  return t(keyMap[category]);
+}
+
+// src/context/memory-operations.ts
+function parseAndAppendToMemory(rawValue, ctx) {
+  const { dataStore, debugLogger, phase, step, collection } = ctx;
+  debugLogger.log({
+    phase,
+    event: "memory_append",
+    step,
+    data: {
+      collection,
+      rawValuePreview: rawValue.slice(0, 200),
+      rawValueLength: rawValue.length
+    }
+  });
+  try {
+    let dataToParse = rawValue;
+    if (dataToParse.startsWith('"') && dataToParse.endsWith('"')) {
+      try {
+        const unquoted = JSON.parse(dataToParse);
+        if (typeof unquoted === "string") {
+          debugLogger.log({
+            phase,
+            event: "memory_append",
+            step,
+            data: { doubleStringifyDetected: true }
+          });
+          dataToParse = unquoted;
+        }
+      } catch {
+      }
+    }
+    const parsed = JSON.parse(dataToParse);
+    if (Array.isArray(parsed)) {
+      const items = parsed.map((item2, i) => {
+        if (typeof item2 === "object" && item2 !== null && !Array.isArray(item2)) {
+          return item2;
+        }
+        return { index: i, value: item2 };
+      });
+      const firstKeys = items.length > 0 ? JSON.stringify(Object.keys(items[0])) : "N/A";
+      debugLogger.log({
+        phase,
+        event: "memory_append",
+        step,
+        data: {
+          parseResult: "array",
+          arrayLength: items.length,
+          firstElementKeys: firstKeys,
+          collection,
+          count: items.length
+        }
+      });
+      dataStore.extend(collection, items);
+      log.success(`Memory: appended ${items.length} items to "${collection}"`);
+      return { appended: items.length };
+    }
+    const item = typeof parsed === "object" && parsed !== null ? parsed : { value: parsed };
+    debugLogger.log({
+      phase,
+      event: "memory_append",
+      step,
+      data: {
+        parseResult: "object",
+        objectKeys: JSON.stringify(Object.keys(item)),
+        collection
+      }
+    });
+    dataStore.append(collection, item);
+    log.success(`Memory: appended 1 item to "${collection}"`);
+    return { appended: 1 };
+  } catch {
+    debugLogger.log({
+      phase,
+      event: "memory_append",
+      step,
+      data: {
+        parseResult: "fallback",
+        collection,
+        rawValuePreview: rawValue.slice(0, 200)
+      }
+    });
+    log.warn(
+      `Memory: could not parse as JSON, storing as {value: "..."} \u2014 extract script should return an array of objects`
+    );
+    dataStore.append(collection, { value: rawValue });
+    return { appended: 1 };
+  }
+}
+
+// src/harness/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/i18n/prompts/en/exploration.ts
+var COMMAND_SCHEMA = `### Basic Operations
+- \`click\`: Click element by selector
+- \`fill\`: Fill value in selector (clears existing value)
+- \`type\`: Type value into selector character by character
+- \`select\`: Select value from dropdown by selector
+- \`check\` / \`uncheck\`: Toggle checkbox by selector
+
+### Navigation
+- \`navigate\`: Navigate to URL in value (only URLs explicitly stated in goal/context; use click for page links)
+- \`wait\`: Wait for value ms
+- \`scroll\`: value: "up"|"down"|"left"|"right"
+
+### Data Extraction
+- \`extract\`: Extract data via script (JS) or extractPrompt (AI). Result in extractedData
+  - **script must return a flat array of objects. No JSON.stringify() needed**
+  - When extracting tables, dynamically get column names from header row
+- \`download\`: Download by clicking selector (specify save path with downloadPath)
+- \`export\`: Export memory data to file (exportCollection, exportFormat: csv|json, exportPath)
+
+### Memory Operations
+- \`memory_append\`: Accumulate data in memoryCollection (value or previous extract result)
+  - **extract and memory_append must be in the same actions array**
+- \`memory_aggregate\`: aggregation: {collection, field, operation: sum|count|concat|min|max|avg|unique_count, outputVariable}
+
+**Use only the actions listed above.**`;
+function getAgentInstructions(goal, contextMarkdown, secrets) {
+  const contextSection = contextMarkdown ? `
+## Supplementary Information
+${contextMarkdown}
+` : "";
+  let secretsSection = "";
+  if (secrets && Object.keys(secrets.values).length > 0) {
+    const entries = Object.entries(secrets.values).map(([key, value]) => `- ${key}: ${value}`).join("\n");
+    secretsSection = `
+## Input Values (secrets)
+Use the following values when filling forms:
+${entries}
+
+**Important**: When using these values, set the corresponding \`variableName\` and choose the appropriate \`inputCategory\` (\`credential\` or \`user_data\`).
+`;
+  }
+  return `You are an AI explorer that navigates web pages to achieve goals.
+Use the browser tool to operate the browser and achieve the goal.
+
+## How to use the browser tool
+
+### Getting a Snapshot
+Call the browser tool with \`actions: []\` (empty array) to get the current page's snapshot (accessibility tree) and URL.
+
+### Executing Actions
+Pass operations as an array in the browser tool's \`actions\`. Keep to 1-3 actions per call.
+
+### Selector Format
+Use \`@eN\` format corresponding to \`[ref=eN]\` in the snapshot (e.g., \`@e1\`, \`@e10\`)
+
+### Available Commands
+${COMMAND_SCHEMA}
+
+### Input Category (inputCategory)
+When entering values with fill/type, always include inputCategory:
+- \`credential\`: Authentication info (username, email, password, etc.)
+- \`user_data\`: User-specific data (name, address, phone number, etc.)
+- \`fixed\`: Fixed values (test values, constants, etc.)
+- \`navigation\`: URLs, search keywords, etc.
+
+### Variable Name (variableName)
+When entering values with fill/type, assign a short English camelCase variable name to \`variableName\`.
+Example: \`email\`, \`password\`, \`searchQuery\`, \`companyName\`, \`firstName\`
+Always use the same name for the same concept (e.g., if email input appears in 2 places, use \`email\` for both).
+
+### Data Capture (suggestedCaptures)
+When important data appears on the page as a result of operations (IDs, order numbers, URL changes, amounts, etc.),
+record them with \`suggestedCaptures\`. Prioritize values needed in subsequent steps.
+Available strategies:
+- \`snapshot\`: Regex match on snapshot (pattern required)
+- \`url\`: Regex match on URL (pattern required)
+- \`ai\`: AI extraction with natural language (prompt required)
+- \`expression\`: Template from existing variables (expression required)
+- \`evaluate\`: Execute JavaScript on page and capture result (expression contains JS code)
+
+Example:
+\`\`\`json
+{
+  "suggestedCaptures": [
+    { "name": "orderId", "strategy": "snapshot", "pattern": "Order[:\uFF1A]\\\\s*([A-Z]+-\\\\d+)", "description": "Order confirmation number" },
+    { "name": "resourceId", "strategy": "url", "pattern": "/orders/(\\\\d+)" }
+  ]
+}
+\`\`\`
+
+## Critical Rules
+- **Only interact with elements visible in the snapshot.** Never guess about elements or URLs that may not exist
+- Navigate pages by clicking links/buttons on screen. Do not guess/construct URLs with \`navigate\` (except URLs explicitly stated in goal or context)
+- Only use \`@eN\` refs that exist as \`[ref=eN]\` in the most recent snapshot
+- If context (supplementary info) is provided, prioritize the procedures, paths, and hints described there
+- If the snapshot shows \`[... N items omitted]\`, the target element may be in the omitted section. Try \`scroll\` to move the view and re-fetch
+
+## Exploration Strategy
+1. First check page state with \`actions: []\`
+2. **Carefully read** the snapshot and identify links, buttons, and form elements related to the goal
+3. Execute operations using the identified \`@eN\` refs
+4. Check results and decide next operation (observe \u2192 decide \u2192 act cycle)
+5. If target element is not found, \`scroll\` to move the view and check the snapshot again
+6. Use \`select\` command for SELECT elements, not \`click\`
+7. Use \`check\` / \`uncheck\` commands for checkboxes
+8. Use \`click\` command for radio buttons \u2014 just click the desired option directly
+9. Never use \`extract\` to investigate form elements. If radio buttons, checkboxes, or dropdowns are visible in the snapshot, interact with them directly using the appropriate command
+
+## Form Input Efficiency
+When filling large forms, strictly follow these rules:
+1. **Enter each field only once** \u2014 Do not re-operate on fields that already have values
+2. **Check filled fields in snapshot** \u2014 After fill/type, the field value appears in the snapshot. Skip fields showing values
+3. **Progress systematically top to bottom** \u2014 Process fieldsets/sections in order. Don't go back to previous sections
+4. **Track filled field count** \u2014 Reference operation history to know what you've already entered. Duplicate operations on the same selector are forbidden
+5. **Submit after all fields are filled** \u2014 Once all required fields are complete, promptly click the submit button
+6. **Check filledFields** \u2014 The browser tool result includes filledFields listing filled fields. Never re-enter fields in this list
+
+## Form Completion Verification
+Before returning your final report when filling forms:
+1. Scan the ENTIRE current snapshot for remaining unfilled fields \u2014 check every fieldset/section
+2. Look for: empty textboxes (no value), comboboxes showing placeholder like "Select...", unchecked checkboxes
+3. The LAST section of a form is commonly missed \u2014 always verify the bottom of the form
+4. After all fields are filled, click the submit/register button
+5. Verify the success confirmation appears before declaring goalAchieved: true
+Do NOT declare goalAchieved without first confirming all form sections are complete and the form is submitted.
+
+## Data Collection Pattern (Pagination Traversal)
+Procedure: extract \u2192 memory_append \u2192 click "Next" \u2192 repeat \u2192 memory_aggregate for aggregation
+
+Example (table extract \u2192 accumulate \u2192 next page \u2192 aggregate \u2192 CSV export):
+\`\`\`json
+[
+  {"action":"extract","description":"Extract table","script":"(()=>{const h=[...document.querySelectorAll('table thead th')].map(t=>t.textContent.trim());return[...document.querySelectorAll('table tbody tr')].map(r=>{const c=r.querySelectorAll('td');return Object.fromEntries([...c].map((c,i)=>[h[i]||'col'+i,c.textContent.trim()]));});})()"},
+  {"action":"memory_append","description":"Accumulate","memoryCollection":"data"},
+  {"action":"click","description":"Next page","selector":"@e15"}
+]
+\`\`\`
+Aggregate: \`[{"action":"memory_aggregate","description":"Sum total","aggregation":{"collection":"data","field":"amount","operation":"sum","outputVariable":"total"}}]\`
+CSV export: \`[{"action":"export","description":"CSV export","exportCollection":"data","exportFormat":"csv","exportPath":"/tmp/data.csv"}]\`
+
+Note: No JSON.stringify() needed in script. Each row is a flat object. Check collection item count via memoryStatus.
+
+**Important**: When paginating, you MUST continue until the LAST page. Check the page indicator (e.g., "Page X of Y") and keep clicking "Next" until you reach the final page. Do NOT stop after a few pages \u2014 process every single page. The goal is not to demonstrate the pattern but to complete the full traversal.
+
+## Using filledFields
+If the browser tool result includes \`filledFields\`, this is a list of already-filled form fields.
+Do not re-enter fields in this list. Only operate on unfilled fields.
+
+## Diff Snapshots
+After text input (fill/type), if page structure hasn't changed, you'll receive a compact snapshot listing all refs.
+- \`Unfilled:\` shows elements you still need to interact with
+- \`Filled:\` shows elements already filled
+- All refs from the compact snapshot are valid and usable
+- If you need full page context, call the browser tool with \`actions: []\`
+
+## Responding to nudgeMessage
+If the browser tool result includes \`nudgeMessage\`, it contains important guidance:
+- **Pagination progress**: Shows current page and remaining pages. You MUST continue until ALL pages are processed.
+- **Loop warning**: Indicates you are repeating the same actions without progress. Try a different approach.
+- **Form hints**: Lists remaining unfilled form fields.
+Always follow the instructions in the message.
+
+## When Goal is Achieved
+When you determine the goal has been achieved \u2014 for form-filling tasks, first verify all fields are filled and the form is submitted \u2014 stop calling the browser tool and return a final report in this JSON format:
+\`\`\`json
+{ "goalAchieved": true, "summary": "Summary of what was accomplished" }
+\`\`\`
+
+If you determine the goal cannot be achieved:
+\`\`\`json
+{ "goalAchieved": false, "summary": "Summary of the situation and reasons" }
+\`\`\`
+
+---
+The following is task-specific information.
+
+## Goal
+${goal}
+${contextSection}${secretsSection}
+Respond in English.`;
+}
+function getInitialUserMessage() {
+  return "Call the browser tool with actions:[] (empty array) to check the current page state. Then begin exploring toward the goal.";
+}
+
+// src/i18n/prompts/ja/exploration.ts
+var COMMAND_SCHEMA2 = `### \u57FA\u672C\u64CD\u4F5C
+- \`click\`: selector \u3067\u8981\u7D20\u30AF\u30EA\u30C3\u30AF
+- \`fill\`: selector \u306B value \u3092\u5165\u529B\uFF08\u65E2\u5B58\u5024\u30AF\u30EA\u30A2\uFF09
+- \`type\`: selector \u306B value \u30921\u6587\u5B57\u305A\u3064\u5165\u529B
+- \`select\`: selector \u306E\u30C9\u30ED\u30C3\u30D7\u30C0\u30A6\u30F3\u3067 value \u3092\u9078\u629E
+- \`check\` / \`uncheck\`: selector \u306E\u30C1\u30A7\u30C3\u30AF\u30DC\u30C3\u30AF\u30B9\u64CD\u4F5C
+
+### \u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3
+- \`navigate\`: value \u306EURL\u306B\u79FB\u52D5\uFF08\u30B4\u30FC\u30EB/\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3067\u660E\u793A\u3055\u308C\u305FURL\u306E\u307F\u3002\u30DA\u30FC\u30B8\u5185\u30EA\u30F3\u30AF\u306F click\uFF09
+- \`wait\`: value ms\u5F85\u6A5F
+- \`scroll\`: value: "up"|"down"|"left"|"right"
+
+### \u30C7\u30FC\u30BF\u62BD\u51FA
+- \`extract\`: script(JS) \u307E\u305F\u306F extractPrompt(AI) \u3067\u30C7\u30FC\u30BF\u62BD\u51FA\u3002\u7D50\u679C\u306F extractedData
+  - **script \u306F\u30D5\u30E9\u30C3\u30C8\u306A\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u914D\u5217\u3092\u8FD4\u3059\u3053\u3068\u3002JSON.stringify()\u4E0D\u8981**
+  - \u30C6\u30FC\u30D6\u30EB\u62BD\u51FA\u6642\u306F\u30D8\u30C3\u30C0\u30FC\u884C\u304B\u3089\u30AB\u30E9\u30E0\u540D\u3092\u52D5\u7684\u53D6\u5F97
+- \`download\`: selector \u30AF\u30EA\u30C3\u30AF\u3067\u30C0\u30A6\u30F3\u30ED\u30FC\u30C9\uFF08downloadPath \u3067\u4FDD\u5B58\u5148\u6307\u5B9A\u53EF\uFF09
+- \`export\`: \u30E1\u30E2\u30EA\u30C7\u30FC\u30BF\u3092\u30D5\u30A1\u30A4\u30EB\u51FA\u529B\uFF08exportCollection, exportFormat: csv|json, exportPath\uFF09
+
+### \u30E1\u30E2\u30EA\u64CD\u4F5C
+- \`memory_append\`: memoryCollection \u306B\u30C7\u30FC\u30BF\u84C4\u7A4D\uFF08value \u307E\u305F\u306F\u76F4\u524D extract \u7D50\u679C\uFF09
+  - **extract \u3068 memory_append \u306F\u5FC5\u305A\u540C\u3058 actions \u914D\u5217\u306B\u542B\u3081\u308B\u3053\u3068**
+- \`memory_aggregate\`: aggregation: {collection, field, operation: sum|count|concat|min|max|avg|unique_count, outputVariable}
+
+**\u4E0A\u8A18\u306E\u30A2\u30AF\u30B7\u30E7\u30F3\u306E\u307F\u4F7F\u7528\u3002**`;
+function getAgentInstructions2(goal, contextMarkdown, secrets) {
+  const contextSection = contextMarkdown ? `
+## \u88DC\u8DB3\u60C5\u5831
+${contextMarkdown}
+` : "";
+  let secretsSection = "";
+  if (secrets && Object.keys(secrets.values).length > 0) {
+    const entries = Object.entries(secrets.values).map(([key, value]) => `- ${key}: ${value}`).join("\n");
+    secretsSection = `
+## \u5165\u529B\u5024\uFF08secrets\uFF09
+\u30D5\u30A9\u30FC\u30E0\u5165\u529B\u6642\u306B\u4EE5\u4E0B\u306E\u5024\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044:
+${entries}
+
+**\u91CD\u8981**: \u3053\u308C\u3089\u306E\u5024\u3092\u4F7F\u7528\u3059\u308B\u969B\u306F\u3001\u5BFE\u5FDC\u3059\u308B \`variableName\` \u3092\u8A2D\u5B9A\u3057\u3001\`inputCategory\` \u306F \`credential\` \u307E\u305F\u306F \`user_data\` \u3092\u9069\u5207\u306B\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+`;
+  }
+  return `\u3042\u306A\u305F\u306FWeb\u30DA\u30FC\u30B8\u3092\u63A2\u7D22\u3057\u3066\u30B4\u30FC\u30EB\u3092\u9054\u6210\u3059\u308BAI\u30A8\u30AF\u30B9\u30D7\u30ED\u30FC\u30E9\u30FC\u3067\u3059\u3002
+browser\u30C4\u30FC\u30EB\u3092\u4F7F\u3063\u3066\u30D6\u30E9\u30A6\u30B6\u3092\u64CD\u4F5C\u3057\u3001\u30B4\u30FC\u30EB\u3092\u9054\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+
+## browser\u30C4\u30FC\u30EB\u306E\u4F7F\u3044\u65B9
+
+### \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u53D6\u5F97
+browser\u30C4\u30FC\u30EB\u3092 \`actions: []\`\uFF08\u7A7A\u914D\u5217\uFF09\u3067\u547C\u3076\u3068\u3001\u73FE\u5728\u306E\u30DA\u30FC\u30B8\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\uFF08\u30A2\u30AF\u30BB\u30B7\u30D3\u30EA\u30C6\u30A3\u30C4\u30EA\u30FC\uFF09\u3068URL\u304C\u8FD4\u308A\u307E\u3059\u3002
+
+### \u30A2\u30AF\u30B7\u30E7\u30F3\u5B9F\u884C
+browser\u30C4\u30FC\u30EB\u306E \`actions\` \u306B\u64CD\u4F5C\u3092\u914D\u5217\u3067\u6E21\u3059\u3068\u9806\u6B21\u5B9F\u884C\u3055\u308C\u307E\u3059\u30021\u56DE\u306E\u547C\u3073\u51FA\u3057\u30671\u301C3\u30A2\u30AF\u30B7\u30E7\u30F3\u7A0B\u5EA6\u306B\u6291\u3048\u3066\u304F\u3060\u3055\u3044\u3002
+
+### \u30BB\u30EC\u30AF\u30BF\u5F62\u5F0F
+\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306E \`[ref=eN]\` \u306B\u5BFE\u5FDC\u3059\u308B \`@eN\` \u5F62\u5F0F\u3067\u6307\u5B9A\uFF08\u4F8B: \`@e1\`, \`@e10\`\uFF09
+
+### \u5229\u7528\u53EF\u80FD\u306A\u30B3\u30DE\u30F3\u30C9
+${COMMAND_SCHEMA2}
+
+### \u5165\u529B\u5024\u306E\u30AB\u30C6\u30B4\u30EA\uFF08inputCategory\uFF09
+fill/type \u3067\u5024\u3092\u5165\u529B\u3059\u308B\u5834\u5408\u3001\u5FC5\u305A inputCategory \u3092\u4ED8\u4E0E:
+- \`credential\`: \u30E6\u30FC\u30B6\u30FC\u540D\u3001\u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u3001\u30D1\u30B9\u30EF\u30FC\u30C9\u7B49\u306E\u8A8D\u8A3C\u60C5\u5831
+- \`user_data\`: \u30E6\u30FC\u30B6\u30FC\u56FA\u6709\u306E\u30C7\u30FC\u30BF\uFF08\u540D\u524D\u3001\u4F4F\u6240\u3001\u96FB\u8A71\u756A\u53F7\u7B49\uFF09
+- \`fixed\`: \u56FA\u5B9A\u5024\uFF08\u30C6\u30B9\u30C8\u5024\u3001\u5B9A\u6570\u7B49\uFF09
+- \`navigation\`: URL\u3001\u691C\u7D22\u30AD\u30FC\u30EF\u30FC\u30C9\u7B49
+
+### \u5909\u6570\u540D\uFF08variableName\uFF09
+fill/type \u3067\u5024\u3092\u5165\u529B\u3059\u308B\u5834\u5408\u3001\u77ED\u3044\u82F1\u8A9E camelCase \u306E\u5909\u6570\u540D\u3092 \`variableName\` \u306B\u4ED8\u4E0E\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+\u4F8B: \`email\`, \`password\`, \`searchQuery\`, \`companyName\`, \`firstName\`
+\u540C\u3058\u6982\u5FF5\u306E\u5024\u306B\u306F\u5FC5\u305A\u540C\u3058\u540D\u524D\u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u4F8B: \u30E1\u30FC\u30EB\u30A2\u30C9\u30EC\u30B9\u5165\u529B\u304C2\u7B87\u6240\u3042\u308C\u3070\u4E21\u65B9 \`email\`\uFF09\u3002
+
+### \u30C7\u30FC\u30BF\u30AD\u30E3\u30D7\u30C1\u30E3\uFF08suggestedCaptures\uFF09
+\u64CD\u4F5C\u7D50\u679C\u3068\u3057\u3066\u91CD\u8981\u306A\u30C7\u30FC\u30BF\uFF08ID\u3001\u6CE8\u6587\u756A\u53F7\u3001URL\u5909\u5316\u3001\u91D1\u984D\u7B49\uFF09\u304C\u30DA\u30FC\u30B8\u306B\u73FE\u308C\u305F\u5834\u5408\u3001
+\`suggestedCaptures\` \u3067\u8A18\u9332\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u5F8C\u7D9A\u30B9\u30C6\u30C3\u30D7\u3067\u53C2\u7167\u304C\u5FC5\u8981\u306B\u306A\u308B\u5024\u3092\u512A\u5148\u3002
+\u5229\u7528\u53EF\u80FD\u306A strategy:
+- \`snapshot\`: \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u6B63\u898F\u8868\u73FE\u30DE\u30C3\u30C1\uFF08pattern \u5FC5\u9808\uFF09
+- \`url\`: URL\u306B\u6B63\u898F\u8868\u73FE\u30DE\u30C3\u30C1\uFF08pattern \u5FC5\u9808\uFF09
+- \`ai\`: AI\u306B\u81EA\u7136\u8A00\u8A9E\u3067\u62BD\u51FA\u3055\u305B\u308B\uFF08prompt \u5FC5\u9808\uFF09
+- \`expression\`: \u65E2\u5B58\u5909\u6570\u304B\u3089\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\u7D44\u307F\u7ACB\u3066\uFF08expression \u5FC5\u9808\uFF09
+- \`evaluate\`: \u30DA\u30FC\u30B8\u5185\u3067JavaScript\u3092\u5B9F\u884C\u3057\u3066\u7D50\u679C\u3092\u30AD\u30E3\u30D7\u30C1\u30E3\uFF08expression \u306BJS\u30B3\u30FC\u30C9\u3092\u6307\u5B9A\uFF09
+
+\u4F8B:
+\`\`\`json
+{
+  "suggestedCaptures": [
+    { "name": "orderId", "strategy": "snapshot", "pattern": "\u6CE8\u6587\u756A\u53F7[:\uFF1A]\\\\s*([A-Z]+-\\\\d+)", "description": "\u6CE8\u6587\u78BA\u8A8D\u756A\u53F7" },
+    { "name": "resourceId", "strategy": "url", "pattern": "/orders/(\\\\d+)" }
+  ]
+}
+\`\`\`
+
+## \u6700\u91CD\u8981\u30EB\u30FC\u30EB
+- **\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u898B\u3048\u3066\u3044\u308B\u8981\u7D20\u3060\u3051\u3092\u64CD\u4F5C\u3059\u308B\u3053\u3068\u3002** \u5B58\u5728\u3059\u308B\u304B\u5206\u304B\u3089\u306A\u3044\u8981\u7D20\u3084URL\u3092\u63A8\u6E2C\u3057\u3066\u306F\u3044\u3051\u306A\u3044
+- \u30DA\u30FC\u30B8\u9077\u79FB\u306F\u753B\u9762\u4E0A\u306E\u30EA\u30F3\u30AF\u3084\u30DC\u30BF\u30F3\u3092 \`click\` \u3067\u884C\u3046\u3002\`navigate\` \u3067URL\u3092\u63A8\u6E2C\u30FB\u7D44\u307F\u7ACB\u3066\u308B\u3053\u3068\u306F\u7981\u6B62\uFF08\u30B4\u30FC\u30EB\u3084\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u3067\u660E\u793A\u3055\u308C\u305FURL\u306F\u9664\u304F\uFF09
+- \u64CD\u4F5C\u5BFE\u8C61\u306E \`@eN\` \u306F\u3001\u76F4\u524D\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B \`[ref=eN]\` \u3068\u3057\u3066\u5B58\u5728\u3059\u308B\u3082\u306E\u3060\u3051\u3092\u4F7F\u7528\u3059\u308B
+- \u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\uFF08\u88DC\u8DB3\u60C5\u5831\uFF09\u304C\u63D0\u4F9B\u3055\u308C\u3066\u3044\u308B\u5834\u5408\u3001\u305D\u3053\u306B\u8A18\u8F09\u3055\u308C\u305F\u624B\u9806\u30FB\u5C0E\u7DDA\u30FB\u30D2\u30F3\u30C8\u3092\u512A\u5148\u7684\u306B\u53C2\u7167\u3059\u308B
+- \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B \`[... N\u4EF6\u7701\u7565]\` \u3068\u3042\u308B\u5834\u5408\u3001\u76EE\u7684\u306E\u8981\u7D20\u304C\u7701\u7565\u90E8\u5206\u306B\u3042\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B\u3002\`scroll\` \u3067\u753B\u9762\u3092\u52D5\u304B\u3057\u3066\u518D\u53D6\u5F97\u3092\u8A66\u307F\u308B\u3053\u3068
+
+## \u63A2\u7D22\u6226\u7565
+1. \u307E\u305A \`actions: []\` \u3067\u30DA\u30FC\u30B8\u72B6\u614B\u3092\u78BA\u8A8D
+2. \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092**\u6CE8\u610F\u6DF1\u304F\u8AAD\u307F**\u3001\u30B4\u30FC\u30EB\u306B\u95A2\u9023\u3059\u308B\u30EA\u30F3\u30AF\u30FB\u30DC\u30BF\u30F3\u30FB\u30D5\u30A9\u30FC\u30E0\u8981\u7D20\u3092\u7279\u5B9A
+3. \u7279\u5B9A\u3057\u305F\u8981\u7D20\u306E \`@eN\` \u3092\u4F7F\u3063\u3066\u64CD\u4F5C\u3092\u5B9F\u884C
+4. \u7D50\u679C\u3092\u78BA\u8A8D\u3057\u3001\u6B21\u306E\u64CD\u4F5C\u3092\u6C7A\u5B9A\uFF08\u89B3\u5BDF\u2192\u5224\u65AD\u2192\u884C\u52D5\u306E\u7E70\u308A\u8FD4\u3057\uFF09
+5. \u76EE\u7684\u306E\u8981\u7D20\u304C\u898B\u3064\u304B\u3089\u306A\u3044\u5834\u5408\u306F \`scroll\` \u3067\u753B\u9762\u3092\u79FB\u52D5\u3057\u3001\u518D\u5EA6\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3092\u78BA\u8A8D\u3059\u308B
+6. SELECT\u8981\u7D20\u306B\u306F \`click\` \u3067\u306F\u306A\u304F \`select\` \u30B3\u30DE\u30F3\u30C9\u3092\u4F7F\u7528
+7. \u30C1\u30A7\u30C3\u30AF\u30DC\u30C3\u30AF\u30B9\u306B\u306F \`check\` / \`uncheck\` \u30B3\u30DE\u30F3\u30C9\u3092\u4F7F\u7528
+8. \u30E9\u30B8\u30AA\u30DC\u30BF\u30F3\u306B\u306F \`click\` \u30B3\u30DE\u30F3\u30C9\u3092\u4F7F\u7528 \u2014 \u9078\u629E\u3057\u305F\u3044\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u76F4\u63A5\u30AF\u30EA\u30C3\u30AF\u3059\u308B
+9. \u30D5\u30A9\u30FC\u30E0\u8981\u7D20\u306E\u8ABF\u67FB\u306B \`extract\` \u3092\u4F7F\u308F\u306A\u3044\u3053\u3068\u3002\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u30E9\u30B8\u30AA\u30DC\u30BF\u30F3\u30FB\u30C1\u30A7\u30C3\u30AF\u30DC\u30C3\u30AF\u30B9\u30FB\u30C9\u30ED\u30C3\u30D7\u30C0\u30A6\u30F3\u304C\u898B\u3048\u3066\u3044\u308C\u3070\u3001\u9069\u5207\u306A\u30B3\u30DE\u30F3\u30C9\u3067\u76F4\u63A5\u64CD\u4F5C\u3059\u308B
+
+## \u30D5\u30A9\u30FC\u30E0\u5165\u529B\u306E\u52B9\u7387\u5316
+\u5927\u304D\u306A\u30D5\u30A9\u30FC\u30E0\u3092\u5165\u529B\u3059\u308B\u969B\u306F\u3001\u4EE5\u4E0B\u306E\u30EB\u30FC\u30EB\u3092\u53B3\u5B88\u3057\u3066\u304F\u3060\u3055\u3044:
+1. **\u5404\u30D5\u30A3\u30FC\u30EB\u30C9\u306F1\u56DE\u3060\u3051\u5165\u529B\u3059\u308B** \u2014 \u65E2\u306B\u5024\u304C\u5165\u529B\u3055\u308C\u305F\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u518D\u5EA6\u64CD\u4F5C\u3057\u306A\u3044\u3053\u3068
+2. **\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u3067\u5165\u529B\u6E08\u307F\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u78BA\u8A8D\u3059\u308B** \u2014 fill/type \u5F8C\u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u306F\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u306B\u5165\u529B\u5024\u304C\u8868\u793A\u3055\u308C\u308B\u3002\u5024\u304C\u8868\u793A\u3055\u308C\u3066\u3044\u308B\u30D5\u30A3\u30FC\u30EB\u30C9\u306F\u30B9\u30AD\u30C3\u30D7\u3059\u308B
+3. **\u4E0A\u304B\u3089\u4E0B\u3078\u4F53\u7CFB\u7684\u306B\u9032\u3080** \u2014 \u30D5\u30A9\u30FC\u30E0\u5185\u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u30BB\u30C3\u30C8/\u30BB\u30AF\u30B7\u30E7\u30F3\u3092\u4E0A\u304B\u3089\u9806\u306B\u51E6\u7406\u3059\u308B\u3002\u524D\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u306B\u623B\u3089\u306A\u3044
+4. **\u5165\u529B\u6E08\u307F\u30D5\u30A3\u30FC\u30EB\u30C9\u6570\u3092\u610F\u8B58\u3059\u308B** \u2014 \u64CD\u4F5C\u5C65\u6B74\u3092\u53C2\u7167\u3057\u3001\u65E2\u306B\u4F55\u3092\u5165\u529B\u3057\u305F\u304B\u3092\u628A\u63E1\u3059\u308B\u3002\u540C\u3058\u30BB\u30EC\u30AF\u30BF\u3078\u306E\u91CD\u8907\u64CD\u4F5C\u306F\u7981\u6B62
+5. **\u5168\u30D5\u30A3\u30FC\u30EB\u30C9\u5165\u529B\u5F8C\u306B\u9001\u4FE1\u3059\u308B** \u2014 \u30D5\u30A9\u30FC\u30E0\u5185\u306E\u5168\u5FC5\u9808\u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u57CB\u307E\u3063\u305F\u3089\u3001\u901F\u3084\u304B\u306B\u9001\u4FE1\u30DC\u30BF\u30F3\u3092\u30AF\u30EA\u30C3\u30AF\u3059\u308B
+6. **filledFields \u3092\u78BA\u8A8D\u3059\u308B** \u2014 browser\u30C4\u30FC\u30EB\u306E\u7D50\u679C\u306B\u542B\u307E\u308C\u308B filledFields \u306F\u5165\u529B\u6E08\u307F\u30D5\u30A3\u30FC\u30EB\u30C9\u306E\u4E00\u89A7\u3002\u3053\u306E\u4E00\u89A7\u306B\u3042\u308B\u30D5\u30A3\u30FC\u30EB\u30C9\u306F\u7D76\u5BFE\u306B\u518D\u5165\u529B\u3057\u306A\u3044\u3053\u3068
+
+## \u30D5\u30A9\u30FC\u30E0\u5B8C\u4E86\u306E\u691C\u8A3C
+\u30D5\u30A9\u30FC\u30E0\u5165\u529B\u306E\u30B4\u30FC\u30EB\u3067\u6700\u7D42\u5831\u544A\u3092\u8FD4\u3059\u524D\u306B:
+1. \u73FE\u5728\u306E\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5168\u4F53\u3092\u30B9\u30AD\u30E3\u30F3\u3057\u3001\u672A\u5165\u529B\u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u306A\u3044\u304B\u78BA\u8A8D \u2014 \u5168\u30D5\u30A3\u30FC\u30EB\u30C9\u30BB\u30C3\u30C8/\u30BB\u30AF\u30B7\u30E7\u30F3\u3092\u30C1\u30A7\u30C3\u30AF
+2. \u4EE5\u4E0B\u3092\u63A2\u3059: \u5024\u306E\u306A\u3044\u30C6\u30AD\u30B9\u30C8\u30DC\u30C3\u30AF\u30B9\u3001\u300CSelect...\u300D\u30D7\u30EC\u30FC\u30B9\u30DB\u30EB\u30C0\u30FC\u8868\u793A\u306E\u30C9\u30ED\u30C3\u30D7\u30C0\u30A6\u30F3\u3001\u672A\u30C1\u30A7\u30C3\u30AF\u306E\u30C1\u30A7\u30C3\u30AF\u30DC\u30C3\u30AF\u30B9
+3. \u30D5\u30A9\u30FC\u30E0\u306E\u6700\u5F8C\u306E\u30BB\u30AF\u30B7\u30E7\u30F3\u306F\u898B\u843D\u3068\u3057\u3084\u3059\u3044 \u2014 \u30D5\u30A9\u30FC\u30E0\u6700\u4E0B\u90E8\u3092\u5FC5\u305A\u78BA\u8A8D
+4. \u5168\u30D5\u30A3\u30FC\u30EB\u30C9\u5165\u529B\u5F8C\u3001\u9001\u4FE1/\u767B\u9332\u30DC\u30BF\u30F3\u3092\u30AF\u30EA\u30C3\u30AF
+5. goalAchieved: true \u3092\u5BA3\u8A00\u3059\u308B\u524D\u306B\u6210\u529F\u78BA\u8A8D\u30E1\u30C3\u30BB\u30FC\u30B8\u306E\u8868\u793A\u3092\u78BA\u8A8D
+\u5168\u30BB\u30AF\u30B7\u30E7\u30F3\u5B8C\u4E86\u30FB\u30D5\u30A9\u30FC\u30E0\u9001\u4FE1\u3092\u78BA\u8A8D\u3059\u308B\u307E\u3067 goalAchieved \u3092\u5BA3\u8A00\u3057\u306A\u3044\u3053\u3068\u3002
+
+## \u30C7\u30FC\u30BF\u53CE\u96C6\u30D1\u30BF\u30FC\u30F3\uFF08\u30DA\u30FC\u30B8\u30CD\u30FC\u30B7\u30E7\u30F3\u8D70\u67FB\uFF09
+\u624B\u9806: extract \u2192 memory_append \u2192 click\u300C\u6B21\u3078\u300D\u2192 \u7E70\u308A\u8FD4\u3057 \u2192 memory_aggregate \u3067\u96C6\u8A08
+
+\u4F8B\uFF08\u30C6\u30FC\u30D6\u30EB\u62BD\u51FA \u2192 \u84C4\u7A4D \u2192 \u6B21\u30DA\u30FC\u30B8 \u2192 \u96C6\u8A08 \u2192 CSV\u51FA\u529B\uFF09:
+\`\`\`json
+[
+  {"action":"extract","description":"\u30C6\u30FC\u30D6\u30EB\u62BD\u51FA","script":"(()=>{const h=[...document.querySelectorAll('table thead th')].map(t=>t.textContent.trim());return[...document.querySelectorAll('table tbody tr')].map(r=>{const c=r.querySelectorAll('td');return Object.fromEntries([...c].map((c,i)=>[h[i]||'col'+i,c.textContent.trim()]));});})()"},
+  {"action":"memory_append","description":"\u84C4\u7A4D","memoryCollection":"data"},
+  {"action":"click","description":"\u6B21\u30DA\u30FC\u30B8","selector":"@e15"}
+]
+\`\`\`
+\u96C6\u8A08: \`[{"action":"memory_aggregate","description":"\u5408\u8A08","aggregation":{"collection":"data","field":"amount","operation":"sum","outputVariable":"total"}}]\`
+CSV\u51FA\u529B: \`[{"action":"export","description":"CSV\u51FA\u529B","exportCollection":"data","exportFormat":"csv","exportPath":"/tmp/data.csv"}]\`
+
+\u6CE8\u610F: script \u3067 JSON.stringify() \u4E0D\u8981\u3002\u5404\u884C\u306F\u30D5\u30E9\u30C3\u30C8\u306A\u30AA\u30D6\u30B8\u30A7\u30AF\u30C8\u3002memoryStatus \u3067\u30B3\u30EC\u30AF\u30B7\u30E7\u30F3\u306E\u30A2\u30A4\u30C6\u30E0\u6570\u3092\u78BA\u8A8D\u53EF\u80FD\u3002
+
+**\u91CD\u8981**: \u30DA\u30FC\u30B8\u30CD\u30FC\u30B7\u30E7\u30F3\u8D70\u67FB\u6642\u306F\u6700\u5F8C\u306E\u30DA\u30FC\u30B8\u307E\u3067\u5FC5\u305A\u7D99\u7D9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u30DA\u30FC\u30B8\u8868\u793A\uFF08\u4F8B: "Page X of Y"\uFF09\u3092\u78BA\u8A8D\u3057\u3001\u6700\u7D42\u30DA\u30FC\u30B8\u306B\u5230\u9054\u3059\u308B\u307E\u3067\u300C\u6B21\u3078\u300D\u3092\u30AF\u30EA\u30C3\u30AF\u3057\u7D9A\u3051\u3066\u304F\u3060\u3055\u3044\u3002\u6570\u30DA\u30FC\u30B8\u3067\u6B62\u3081\u305A\u3001\u5168\u30DA\u30FC\u30B8\u3092\u51E6\u7406\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u30D1\u30BF\u30FC\u30F3\u3092\u793A\u3059\u3053\u3068\u304C\u76EE\u7684\u3067\u306F\u306A\u304F\u3001\u5168\u30C7\u30FC\u30BF\u306E\u8D70\u67FB\u3092\u5B8C\u4E86\u3059\u308B\u3053\u3068\u304C\u76EE\u7684\u3067\u3059\u3002
+
+## filledFields \u306E\u6D3B\u7528
+browser\u30C4\u30FC\u30EB\u306E\u7D50\u679C\u306B \`filledFields\` \u304C\u542B\u307E\u308C\u3066\u3044\u308B\u5834\u5408\u3001\u3053\u308C\u306F\u65E2\u306B\u5165\u529B\u6E08\u307F\u306E\u30D5\u30A9\u30FC\u30E0\u30D5\u30A3\u30FC\u30EB\u30C9\u306E\u4E00\u89A7\u3067\u3059\u3002
+\u30EA\u30B9\u30C8\u306B\u542B\u307E\u308C\u308B\u30D5\u30A3\u30FC\u30EB\u30C9\u306B\u306F\u518D\u5EA6\u5165\u529B\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002\u672A\u5165\u529B\u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u306E\u307F\u3092\u64CD\u4F5C\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+
+## \u5DEE\u5206\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8
+\u30C6\u30AD\u30B9\u30C8\u5165\u529B\uFF08fill/type\uFF09\u5F8C\u306B\u30DA\u30FC\u30B8\u69CB\u9020\u304C\u5909\u308F\u3063\u3066\u3044\u306A\u3044\u5834\u5408\u3001\u5168ref\u3092\u4E00\u89A7\u306B\u3057\u305F\u30B3\u30F3\u30D1\u30AF\u30C8\u306A\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304C\u8FD4\u3055\u308C\u307E\u3059\u3002
+- \`Unfilled:\` \u306F\u307E\u3060\u64CD\u4F5C\u304C\u5FC5\u8981\u306A\u8981\u7D20\u3092\u793A\u3057\u307E\u3059
+- \`Filled:\` \u306F\u5165\u529B\u6E08\u307F\u306E\u8981\u7D20\u3092\u793A\u3057\u307E\u3059
+- \u30B3\u30F3\u30D1\u30AF\u30C8\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5185\u306E\u5168ref\u306F\u6709\u52B9\u3067\u4F7F\u7528\u53EF\u80FD\u3067\u3059
+- \u5B8C\u5168\u306A\u30DA\u30FC\u30B8\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u304C\u5FC5\u8981\u306A\u5834\u5408\u306F \`actions: []\` \u3067\u30D6\u30E9\u30A6\u30B6\u30C4\u30FC\u30EB\u3092\u547C\u3073\u51FA\u3057\u3066\u304F\u3060\u3055\u3044
+
+## nudgeMessage \u3078\u306E\u5BFE\u5FDC
+browser\u30C4\u30FC\u30EB\u306E\u7D50\u679C\u306B \`nudgeMessage\` \u304C\u542B\u307E\u308C\u3066\u3044\u308B\u5834\u5408\u3001\u91CD\u8981\u306A\u30AC\u30A4\u30C0\u30F3\u30B9\u304C\u8A18\u8F09\u3055\u308C\u3066\u3044\u307E\u3059:
+- **\u30DA\u30FC\u30B8\u30CD\u30FC\u30B7\u30E7\u30F3\u9032\u6357**: \u73FE\u5728\u306E\u30DA\u30FC\u30B8\u3068\u6B8B\u308A\u30DA\u30FC\u30B8\u6570\u3092\u793A\u3057\u307E\u3059\u3002\u5168\u30DA\u30FC\u30B8\u306E\u51E6\u7406\u304C\u5B8C\u4E86\u3059\u308B\u307E\u3067\u7D9A\u884C\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+- **\u30EB\u30FC\u30D7\u8B66\u544A**: \u540C\u3058\u64CD\u4F5C\u3092\u7E70\u308A\u8FD4\u3057\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002\u5225\u306E\u30A2\u30D7\u30ED\u30FC\u30C1\u3092\u8A66\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+- **\u30D5\u30A9\u30FC\u30E0\u30D2\u30F3\u30C8**: \u672A\u5165\u529B\u306E\u30D5\u30A9\u30FC\u30E0\u30D5\u30A3\u30FC\u30EB\u30C9\u4E00\u89A7\u3067\u3059\u3002
+\u30E1\u30C3\u30BB\u30FC\u30B8\u306E\u6307\u793A\u306B\u5FC5\u305A\u5F93\u3063\u3066\u304F\u3060\u3055\u3044\u3002
+
+## \u30B4\u30FC\u30EB\u9054\u6210\u6642
+\u30B4\u30FC\u30EB\u304C\u9054\u6210\u3055\u308C\u305F\u3068\u5224\u65AD\u3057\u305F\u3089 \u2014 \u30D5\u30A9\u30FC\u30E0\u5165\u529B\u30BF\u30B9\u30AF\u306E\u5834\u5408\u3001\u5168\u30D5\u30A3\u30FC\u30EB\u30C9\u304C\u5165\u529B\u6E08\u307F\u3067\u30D5\u30A9\u30FC\u30E0\u304C\u9001\u4FE1\u6E08\u307F\u3067\u3042\u308B\u3053\u3068\u3092\u5148\u306B\u78BA\u8A8D\u3059\u308B\u3053\u3068 \u2014 browser\u30C4\u30FC\u30EB\u306E\u547C\u3073\u51FA\u3057\u3092\u505C\u6B62\u3057\u3001\u4EE5\u4E0B\u306EJSON\u5F62\u5F0F\u3067\u6700\u7D42\u5831\u544A\u3092\u8FD4\u3057\u3066\u304F\u3060\u3055\u3044:
+\`\`\`json
+{ "goalAchieved": true, "summary": "\u9054\u6210\u5185\u5BB9\u306E\u8981\u7D04" }
+\`\`\`
+
+\u30B4\u30FC\u30EB\u304C\u9054\u6210\u3067\u304D\u306A\u3044\u3068\u5224\u65AD\u3057\u305F\u5834\u5408\u3082\u540C\u69D8\u306B:
+\`\`\`json
+{ "goalAchieved": false, "summary": "\u72B6\u6CC1\u306E\u8981\u7D04\u3068\u7406\u7531" }
+\`\`\`
+
+---
+\u4EE5\u4E0B\u306F\u3053\u306E\u30BF\u30B9\u30AF\u56FA\u6709\u306E\u60C5\u5831\u3067\u3059\u3002
+
+## \u30B4\u30FC\u30EB
+${goal}
+${contextSection}${secretsSection}
+\u65E5\u672C\u8A9E\u3067\u5FDC\u7B54\u3057\u3066\u304F\u3060\u3055\u3044\u3002`;
+}
+function getInitialUserMessage2() {
+  return "browser\u30C4\u30FC\u30EB\u3092actions:[]\uFF08\u7A7A\u914D\u5217\uFF09\u3067\u547C\u3073\u51FA\u3057\u3001\u73FE\u5728\u306E\u30DA\u30FC\u30B8\u72B6\u614B\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u305D\u306E\u5F8C\u3001\u30B4\u30FC\u30EB\u9054\u6210\u306B\u5411\u3051\u3066\u63A2\u7D22\u3092\u958B\u59CB\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+}
+
+// src/i18n/prompts/en/review.ts
+function getReviewSystemPrompt() {
+  return `You are an expert reviewer of web browser automation procedures.
+
+## Task
+Analyze the recorded steps and determine the following:
+
+1. **Remove unnecessary steps**: Identify and exclude trial-and-error during exploration, dead ends, unnecessary navigation, and duplicate operations
+2. **Risk level assessment**: Assess the risk of each step
+   - \`low\`: Low side-effect operations like input, scrolling, navigation
+   - \`medium\`: Login, form submission, settings changes, etc.
+   - \`high\`: Irreversible operations like deletion, payment, data modification
+3. **Approval requirement**: Whether user approval is needed before execution
+
+## Capture Candidate Identification
+If you detect important data used in subsequent steps (IDs, order numbers, URL changes, amounts, etc.),
+include them as suggestedCaptures in each step's response.
+Available strategies: snapshot (regex), url (URL regex), ai (AI extraction), expression (template)
+
+## Notes
+- Failed steps (success=false) should generally be excluded
+- Keep only the shortest path steps needed to achieve the goal
+- riskLevel is used in the Chrome extension approval flow (medium/high requires approval)
+- Respond in English`;
+}
+function createReviewUserPrompt(goal, recordedSteps, goalAchieved, interventions) {
+  const stepsList = recordedSteps.map(
+    (s) => `${s.ordinal}. [${s.success ? "OK" : "FAIL"}] ${s.action.description} (action: ${s.action.action}, url: ${s.url})${s.error ? ` Error: ${s.error}` : ""}`
+  ).join("\n");
+  const interventionsSection = interventions && interventions.length > 0 ? `
+## User Interventions During Exploration
+The user modified the exploration direction at the following points.
+Steps before the intervention likely contain trial-and-error, while steps after are more accurate.
+
+${interventions.map(
+    (iv, i) => `${i + 1}. Around step #${iv.stepIndex}: "${iv.userInstruction}" (URL: ${iv.url})`
+  ).join("\n")}
+
+**Review note**: Actively exclude unnecessary steps before intervention points.
+` : "";
+  return `## Goal
+${goal}
+
+## Goal Achievement Status
+${goalAchieved ? "Achieved" : "Not achieved"}
+${interventionsSection}
+## All Recorded Steps
+${stepsList}`;
+}
+
+// src/i18n/prompts/ja/review.ts
+function getReviewSystemPrompt2() {
+  return `\u3042\u306A\u305F\u306FWeb\u30D6\u30E9\u30A6\u30B6\u81EA\u52D5\u64CD\u4F5C\u306E\u624B\u9806\u66F8\u3092\u30EC\u30D3\u30E5\u30FC\u3059\u308B\u30A8\u30AD\u30B9\u30D1\u30FC\u30C8\u3067\u3059\u3002
+
+## \u30BF\u30B9\u30AF
+\u8A18\u9332\u3055\u308C\u305F\u30B9\u30C6\u30C3\u30D7\u3092\u5206\u6790\u3057\u3001\u4EE5\u4E0B\u3092\u5224\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044:
+
+1. **\u4E0D\u8981\u30B9\u30C6\u30C3\u30D7\u306E\u9664\u5916**: \u63A2\u7D22\u4E2D\u306E\u8A66\u884C\u932F\u8AA4\u3001\u884C\u304D\u6B62\u307E\u308A\u3001\u4E0D\u8981\u306A\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u3001\u91CD\u8907\u64CD\u4F5C\u3092\u7279\u5B9A\u3057\u9664\u5916
+2. **\u30EA\u30B9\u30AF\u30EC\u30D9\u30EB\u5224\u5B9A**: \u5404\u30B9\u30C6\u30C3\u30D7\u306E\u30EA\u30B9\u30AF\u3092\u5224\u5B9A
+   - \`low\`: \u5165\u529B\u3001\u30B9\u30AF\u30ED\u30FC\u30EB\u3001\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u306A\u3069\u526F\u4F5C\u7528\u306E\u5C11\u306A\u3044\u64CD\u4F5C
+   - \`medium\`: \u30ED\u30B0\u30A4\u30F3\u3001\u30D5\u30A9\u30FC\u30E0\u9001\u4FE1\u3001\u8A2D\u5B9A\u5909\u66F4\u306A\u3069
+   - \`high\`: \u524A\u9664\u3001\u6C7A\u6E08\u3001\u30C7\u30FC\u30BF\u5909\u66F4\u306A\u3069\u4E0D\u53EF\u9006\u306A\u64CD\u4F5C
+3. **\u627F\u8A8D\u8981\u5426\u5224\u5B9A**: \u5B9F\u884C\u524D\u306B\u30E6\u30FC\u30B6\u30FC\u627F\u8A8D\u304C\u5FC5\u8981\u304B\u3069\u3046\u304B
+
+## \u30AD\u30E3\u30D7\u30C1\u30E3\u5019\u88DC\u306E\u8B58\u5225
+\u64CD\u4F5C\u7D50\u679C\u3068\u3057\u3066\u5F8C\u7D9A\u30B9\u30C6\u30C3\u30D7\u3067\u4F7F\u7528\u3055\u308C\u308B\u91CD\u8981\u306A\u30C7\u30FC\u30BF\uFF08ID\u3001\u6CE8\u6587\u756A\u53F7\u3001URL\u5909\u5316\u3001\u91D1\u984D\u306A\u3069\uFF09\u3092\u691C\u51FA\u3057\u305F\u5834\u5408\u3001
+suggestedCaptures \u3068\u3057\u3066\u30EC\u30B9\u30DD\u30F3\u30B9\u306E\u5404\u30B9\u30C6\u30C3\u30D7\u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002
+\u5229\u7528\u53EF\u80FD\u306A strategy: snapshot\uFF08\u6B63\u898F\u8868\u73FE\uFF09, url\uFF08URL\u6B63\u898F\u8868\u73FE\uFF09, ai\uFF08AI\u62BD\u51FA\uFF09, expression\uFF08\u30C6\u30F3\u30D7\u30EC\u30FC\u30C8\uFF09
+
+## \u6CE8\u610F\u4E8B\u9805
+- \u5931\u6557\u30B9\u30C6\u30C3\u30D7\uFF08success=false\uFF09\u306F\u57FA\u672C\u7684\u306B\u9664\u5916\u3057\u3066\u304F\u3060\u3055\u3044
+- \u30B4\u30FC\u30EB\u9054\u6210\u306B\u5FC5\u8981\u306A\u6700\u77ED\u7D4C\u8DEF\u306E\u30B9\u30C6\u30C3\u30D7\u306E\u307F\u6B8B\u3057\u3066\u304F\u3060\u3055\u3044
+- riskLevel \u306F Chrome\u62E1\u5F35\u306E\u627F\u8A8D\u30D5\u30ED\u30FC\u3067\u4F7F\u7528\u3055\u308C\u307E\u3059\uFF08medium/high \u306F\u627F\u8A8D\u304C\u5FC5\u8981\uFF09
+- \u65E5\u672C\u8A9E\u3067\u5FDC\u7B54\u3057\u3066\u304F\u3060\u3055\u3044`;
+}
+function createReviewUserPrompt2(goal, recordedSteps, goalAchieved, interventions) {
+  const stepsList = recordedSteps.map(
+    (s) => `${s.ordinal}. [${s.success ? "\u6210\u529F" : "\u5931\u6557"}] ${s.action.description} (action: ${s.action.action}, url: ${s.url})${s.error ? ` \u30A8\u30E9\u30FC: ${s.error}` : ""}`
+  ).join("\n");
+  const interventionsSection = interventions && interventions.length > 0 ? `
+## \u63A2\u7D22\u4E2D\u306E\u30E6\u30FC\u30B6\u30FC\u4ECB\u5165
+\u4EE5\u4E0B\u306E\u30BF\u30A4\u30DF\u30F3\u30B0\u3067\u30E6\u30FC\u30B6\u30FC\u304C\u63A2\u7D22\u65B9\u91DD\u3092\u4FEE\u6B63\u3057\u307E\u3057\u305F\u3002
+\u4ECB\u5165\u524D\u306E\u30B9\u30C6\u30C3\u30D7\u306B\u306F\u63A2\u7D22\u306E\u8A66\u884C\u932F\u8AA4\u304C\u542B\u307E\u308C\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u9AD8\u304F\u3001\u4ECB\u5165\u5F8C\u306E\u30B9\u30C6\u30C3\u30D7\u304C\u3088\u308A\u6B63\u78BA\u306A\u624B\u9806\u3067\u3059\u3002
+
+${interventions.map(
+    (iv, i) => `${i + 1}. \u30B9\u30C6\u30C3\u30D7#${iv.stepIndex}\u4ED8\u8FD1: "${iv.userInstruction}" (URL: ${iv.url})`
+  ).join("\n")}
+
+**\u30EC\u30D3\u30E5\u30FC\u6642\u306E\u6CE8\u610F**: \u4ECB\u5165\u30DD\u30A4\u30F3\u30C8\u3088\u308A\u524D\u306E\u4E0D\u8981\u306A\u30B9\u30C6\u30C3\u30D7\u306F\u7A4D\u6975\u7684\u306B\u9664\u5916\u3057\u3066\u304F\u3060\u3055\u3044\u3002
+` : "";
+  return `## \u30B4\u30FC\u30EB
+${goal}
+
+## \u30B4\u30FC\u30EB\u9054\u6210\u72B6\u6CC1
+${goalAchieved ? "\u9054\u6210\u6E08\u307F" : "\u672A\u9054\u6210"}
+${interventionsSection}
+## \u8A18\u9332\u3055\u308C\u305F\u5168\u30B9\u30C6\u30C3\u30D7
+${stepsList}`;
+}
+
+// src/i18n/prompts/en/selector.ts
+function buildSelectorMessages(snapshot, selector, stepDescription, url, contextMarkdown, retryContext, workingMemorySummary) {
+  const system = [
+    "You are a selector resolver for browser automation.",
+    "Based on the step description, identify the target element in the accessibility snapshot.",
+    "",
+    "## Matching Guidelines",
+    "1. Infer the type of target element (button, input field, link, etc.) from the step description",
+    "2. Find the element in the snapshot that semantically best matches the step description",
+    "3. Use surrounding text, labels, placeholders, and roles as clues",
+    "4. Even without an exact match, return the ref of the most likely element",
+    "5. Return an empty string only if the target element truly does not exist in the snapshot"
+  ].join("\n");
+  const parts = [
+    "## Step Description (Most Important)",
+    stepDescription,
+    "",
+    "## Selector Hints (Reference)",
+    "The following is reference information for identifying the element. Even without an exact match, choose the element semantically closest to the step description.",
+    JSON.stringify(pruneSelectorHints(selector)),
+    "",
+    "Notes:",
+    '- If tagName is "unknown" or ":", there is no tag name information',
+    "- ariaLabel is auto-generated from the step description and may not match the actual aria-label attribute",
+    "- Prioritize semantic match with the step description over exact selector match",
+    "",
+    "## Current URL",
+    url
+  ];
+  if (workingMemorySummary) {
+    parts.push("", "## Execution Context", workingMemorySummary);
+  }
+  parts.push(
+    "",
+    "## Accessibility Snapshot",
+    snapshot
+  );
+  const includeContext = contextMarkdown && !(retryContext && retryContext.attempt > 0);
+  if (includeContext) {
+    parts.push("", "## Supplementary Context", contextMarkdown);
+  }
+  if (retryContext && retryContext.attempt > 0) {
+    parts.push(
+      "",
+      "## Recovery Context (Attempt " + (retryContext.attempt + 1) + ")"
+    );
+    if (retryContext.failureHints) {
+      parts.push(`Pattern: ${retryContext.failureHints}`);
+    }
+    if (retryContext.failureHistory.length > 0) {
+      const recent = retryContext.failureHistory.slice(-2);
+      parts.push(`Previous: ${recent.join("; ")}`);
+    }
+    if (retryContext.previousAiResponse) {
+      try {
+        const parsed = JSON.parse(retryContext.previousAiResponse);
+        if (parsed.reasoning) {
+          parts.push(`Last reasoning: "${parsed.reasoning}"`);
+        }
+      } catch {
+        parts.push(`Last response: ${retryContext.previousAiResponse.slice(0, 200)}`);
+      }
+    }
+    if (!retryContext.snapshotChanged) {
+      parts.push(
+        "Snapshot unchanged \u2014 try partial matching, role-based matching, or inference from nearby elements."
+      );
+    }
+  }
+  return { system, userPrompt: parts.join("\n") };
+}
+function pruneSelectorHints(selector) {
+  const pruned = {};
+  for (const [key, value] of Object.entries(selector)) {
+    if (value === null || value === void 0 || value === "" || value === "unknown" || value === ":") continue;
+    pruned[key] = value;
+  }
+  return pruned;
+}
+
+// src/i18n/prompts/ja/selector.ts
+function buildSelectorMessages2(snapshot, selector, stepDescription, url, contextMarkdown, retryContext, workingMemorySummary) {
+  const system = [
+    "\u3042\u306A\u305F\u306F\u30D6\u30E9\u30A6\u30B6\u81EA\u52D5\u64CD\u4F5C\u306E\u30BB\u30EC\u30AF\u30BF\u30EA\u30BE\u30EB\u30D0\u30FC\u3067\u3059\u3002",
+    "\u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\u306B\u57FA\u3065\u3044\u3066\u3001\u30A2\u30AF\u30BB\u30B7\u30D3\u30EA\u30C6\u30A3\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5185\u306E\u64CD\u4F5C\u5BFE\u8C61\u8981\u7D20\u3092\u7279\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    "",
+    "## \u30DE\u30C3\u30C1\u30F3\u30B0\u306E\u6307\u91DD",
+    "1. \u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\u304B\u3089\u64CD\u4F5C\u5BFE\u8C61\u306E\u8981\u7D20\u306E\u7A2E\u985E\uFF08\u30DC\u30BF\u30F3\u3001\u5165\u529B\u30D5\u30A3\u30FC\u30EB\u30C9\u3001\u30EA\u30F3\u30AF\u7B49\uFF09\u3092\u63A8\u5B9A\u3059\u308B",
+    "2. \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5185\u3067\u3001\u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\u3068\u610F\u5473\u7684\u306B\u6700\u3082\u4E00\u81F4\u3059\u308B\u8981\u7D20\u3092\u63A2\u3059",
+    "3. \u5468\u8FBA\u306E\u30C6\u30AD\u30B9\u30C8\u3001\u30E9\u30D9\u30EB\u3001\u30D7\u30EC\u30FC\u30B9\u30DB\u30EB\u30C0\u30FC\u3001role \u3082\u624B\u304C\u304B\u308A\u306B\u3059\u308B",
+    "4. \u5B8C\u5168\u4E00\u81F4\u304C\u306A\u304F\u3066\u3082\u6700\u3082\u53EF\u80FD\u6027\u306E\u9AD8\u3044\u8981\u7D20\u306E ref \u3092\u8FD4\u3059",
+    "5. \u8A72\u5F53\u3059\u308B\u8981\u7D20\u304C\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5185\u306B\u672C\u5F53\u306B\u5B58\u5728\u3057\u306A\u3044\u5834\u5408\u306E\u307F\u7A7A\u6587\u5B57\u3092\u8FD4\u3059"
+  ].join("\n");
+  const parts = [
+    "## \u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\uFF08\u6700\u91CD\u8981\uFF09",
+    stepDescription,
+    "",
+    "## \u30BB\u30EC\u30AF\u30BF\u306E\u30D2\u30F3\u30C8\uFF08\u53C2\u8003\u60C5\u5831\uFF09",
+    "\u4EE5\u4E0B\u306F\u8981\u7D20\u3092\u7279\u5B9A\u3059\u308B\u305F\u3081\u306E\u53C2\u8003\u60C5\u5831\u3067\u3059\u3002\u5B8C\u5168\u4E00\u81F4\u3057\u306A\u3044\u5834\u5408\u3067\u3082\u3001\u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\u304B\u3089\u610F\u5473\u7684\u306B\u6700\u3082\u8FD1\u3044\u8981\u7D20\u3092\u9078\u3093\u3067\u304F\u3060\u3055\u3044\u3002",
+    JSON.stringify(pruneSelectorHints2(selector)),
+    "",
+    "\u6CE8\u610F:",
+    '- tagName \u304C "unknown" \u3084 ":" \u306E\u5834\u5408\u306F\u30BF\u30B0\u540D\u60C5\u5831\u304C\u3042\u308A\u307E\u305B\u3093',
+    "- ariaLabel \u306F\u30B9\u30C6\u30C3\u30D7\u8AAC\u660E\u304B\u3089\u81EA\u52D5\u751F\u6210\u3055\u308C\u305F\u3082\u306E\u3067\u3042\u308A\u3001\u5B9F\u969B\u306E aria-label \u5C5E\u6027\u3068\u4E00\u81F4\u3057\u306A\u3044\u3053\u3068\u304C\u3042\u308A\u307E\u3059",
+    "- \u30BB\u30EC\u30AF\u30BF\u306E\u5B8C\u5168\u4E00\u81F4\u3088\u308A\u3082\u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\u3068\u306E\u610F\u5473\u7684\u4E00\u81F4\u3092\u512A\u5148\u3057\u3066\u304F\u3060\u3055\u3044",
+    "",
+    "## \u73FE\u5728\u306EURL",
+    url
+  ];
+  if (workingMemorySummary) {
+    parts.push("", "## \u5B9F\u884C\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8", workingMemorySummary);
+  }
+  parts.push(
+    "",
+    "## \u30A2\u30AF\u30BB\u30B7\u30D3\u30EA\u30C6\u30A3\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8",
+    snapshot
+  );
+  const includeContext = contextMarkdown && !(retryContext && retryContext.attempt > 0);
+  if (includeContext) {
+    parts.push("", "## \u88DC\u8DB3\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8", contextMarkdown);
+  }
+  if (retryContext && retryContext.attempt > 0) {
+    parts.push(
+      "",
+      "## \u56DE\u5FA9\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\uFF08\u8A66\u884C" + (retryContext.attempt + 1) + "\u56DE\u76EE\uFF09"
+    );
+    if (retryContext.failureHints) {
+      parts.push(`\u30D1\u30BF\u30FC\u30F3: ${retryContext.failureHints}`);
+    }
+    if (retryContext.failureHistory.length > 0) {
+      const recent = retryContext.failureHistory.slice(-2);
+      parts.push(`\u76F4\u8FD1\u306E\u5931\u6557: ${recent.join("; ")}`);
+    }
+    if (retryContext.previousAiResponse) {
+      try {
+        const parsed = JSON.parse(retryContext.previousAiResponse);
+        if (parsed.reasoning) {
+          parts.push(`\u524D\u56DE\u306E\u63A8\u8AD6: "${parsed.reasoning}"`);
+        }
+      } catch {
+        parts.push(`\u524D\u56DE\u306E\u5FDC\u7B54: ${retryContext.previousAiResponse.slice(0, 200)}`);
+      }
+    }
+    if (!retryContext.snapshotChanged) {
+      parts.push(
+        "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u672A\u5909\u5316 \u2014 \u90E8\u5206\u4E00\u81F4\u3001role\u30D9\u30FC\u30B9\u306E\u30DE\u30C3\u30C1\u30F3\u30B0\u3001\u8FD1\u63A5\u8981\u7D20\u304B\u3089\u306E\u63A8\u5B9A\u3092\u8A66\u307F\u3066\u304F\u3060\u3055\u3044\u3002"
+      );
+    }
+  }
+  return { system, userPrompt: parts.join("\n") };
+}
+function pruneSelectorHints2(selector) {
+  const pruned = {};
+  for (const [key, value] of Object.entries(selector)) {
+    if (value === null || value === void 0 || value === "" || value === "unknown" || value === ":") continue;
+    pruned[key] = value;
+  }
+  return pruned;
+}
+
+// src/i18n/prompts/en/goal-agent.ts
+function buildFallbackMessages(snapshot, step, failureHistory, url, contextMarkdown) {
+  const system = [
+    "You are a problem-solving agent for browser automation.",
+    "Normal selector resolution has failed at all phases. Analyze the entire page and find an alternative operation path.",
+    "",
+    "## Alternative Path Search Guidelines",
+    "1. Check if the target element is hidden inside a hamburger menu, dropdown, or accordion",
+    "2. Check if a modal or overlay is covering the target element",
+    "3. Check if the page is in an unexpected state (not logged in, error state, loading)",
+    "4. Check if the target element is above the current scroll position",
+    "5. Check if a semantically equivalent alternative element exists (e.g., a button instead of a link)",
+    "",
+    "## Alternative Strategy Selection Criteria",
+    "- direct_ref: Try a different ref directly (when a semantically equivalent element is found)",
+    "- scroll_up_and_retry: When the target element might be above the current view",
+    "- expand_collapsed: When a collapsed section/menu needs to be expanded (prerequisiteRef required)",
+    "- dismiss_overlay: When a modal/overlay needs to be closed (prerequisiteRef required)",
+    "- tab_navigation: When the element can be reached via Tab key focus navigation",
+    "- not_found: When the target element truly does not exist on the page"
+  ].join("\n");
+  const parts = [
+    "## Step Being Attempted",
+    `Description: ${step.description}`,
+    `Action: ${step.action.type}`,
+    `Selector hints: ${JSON.stringify(step.action.selector, null, 2)}`,
+    `URL: ${url}`,
+    "",
+    "## Failure History",
+    ...failureHistory.map((f, i) => `  ${i + 1}. ${f}`),
+    "",
+    "## Current Page Snapshot (Filtered)",
+    snapshot
+  ];
+  if (contextMarkdown) {
+    parts.push("", "## Supplementary Context", contextMarkdown);
+  }
+  return { system, userPrompt: parts.join("\n") };
+}
+
+// src/i18n/prompts/ja/goal-agent.ts
+function buildFallbackMessages2(snapshot, step, failureHistory, url, contextMarkdown) {
+  const system = [
+    "\u3042\u306A\u305F\u306F\u30D6\u30E9\u30A6\u30B6\u81EA\u52D5\u64CD\u4F5C\u306E\u554F\u984C\u89E3\u6C7A\u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u3067\u3059\u3002",
+    "\u901A\u5E38\u306E\u30BB\u30EC\u30AF\u30BF\u89E3\u6C7A\u304C\u5168\u30D5\u30A7\u30FC\u30BA\u5931\u6557\u3057\u307E\u3057\u305F\u3002\u30DA\u30FC\u30B8\u5168\u4F53\u3092\u5206\u6790\u3057\u3066\u4EE3\u66FF\u64CD\u4F5C\u30D1\u30B9\u3092\u898B\u3064\u3051\u3066\u304F\u3060\u3055\u3044\u3002",
+    "",
+    "## \u4EE3\u66FF\u30D1\u30B9\u63A2\u7D22\u306E\u6307\u91DD",
+    "1. \u30CF\u30F3\u30D0\u30FC\u30AC\u30FC\u30E1\u30CB\u30E5\u30FC\u3001\u30C9\u30ED\u30C3\u30D7\u30C0\u30A6\u30F3\u3001\u30A2\u30B3\u30FC\u30C7\u30A3\u30AA\u30F3\u306E\u4E2D\u306B\u5BFE\u8C61\u8981\u7D20\u304C\u96A0\u308C\u3066\u3044\u306A\u3044\u304B\u78BA\u8A8D",
+    "2. \u30E2\u30FC\u30C0\u30EB\u3084\u30AA\u30FC\u30D0\u30FC\u30EC\u30A4\u304C\u524D\u9762\u306B\u3042\u3063\u3066\u5BFE\u8C61\u8981\u7D20\u3092\u96A0\u3057\u3066\u3044\u306A\u3044\u304B\u78BA\u8A8D",
+    "3. \u30DA\u30FC\u30B8\u304C\u60F3\u5B9A\u3068\u7570\u306A\u308B\u72B6\u614B\uFF08\u672A\u30ED\u30B0\u30A4\u30F3\u3001\u30A8\u30E9\u30FC\u72B6\u614B\u3001\u30ED\u30FC\u30C7\u30A3\u30F3\u30B0\u4E2D\uFF09\u3067\u306A\u3044\u304B\u78BA\u8A8D",
+    "4. \u5BFE\u8C61\u8981\u7D20\u304C\u4E0A\u65B9\u306B\u3042\u3063\u3066\u30B9\u30AF\u30ED\u30FC\u30EB\u3067\u96A0\u308C\u3066\u3044\u306A\u3044\u304B\u78BA\u8A8D",
+    "5. \u610F\u5473\u7684\u306B\u540C\u7B49\u306A\u5225\u306E\u8981\u7D20\uFF08\u30EA\u30F3\u30AF\u3067\u306F\u306A\u304F\u30DC\u30BF\u30F3\u3001\u7B49\uFF09\u304C\u5B58\u5728\u3057\u306A\u3044\u304B\u78BA\u8A8D",
+    "",
+    "## \u4EE3\u66FF\u6226\u7565\u306E\u9078\u629E\u57FA\u6E96",
+    "- direct_ref: \u5225\u306E ref \u3092\u76F4\u63A5\u8A66\u3059\uFF08\u610F\u5473\u7684\u306B\u540C\u7B49\u306A\u8981\u7D20\u304C\u898B\u3064\u304B\u3063\u305F\u5834\u5408\uFF09",
+    "- scroll_up_and_retry: \u5BFE\u8C61\u8981\u7D20\u304C\u4E0A\u65B9\u306B\u3042\u308B\u53EF\u80FD\u6027\u304C\u3042\u308B\u5834\u5408",
+    "- expand_collapsed: \u6298\u308A\u7573\u307E\u308C\u305F\u30BB\u30AF\u30B7\u30E7\u30F3/\u30E1\u30CB\u30E5\u30FC\u3092\u5C55\u958B\u3059\u308B\u5FC5\u8981\u304C\u3042\u308B\u5834\u5408\uFF08prerequisiteRef \u5FC5\u9808\uFF09",
+    "- dismiss_overlay: \u30E2\u30FC\u30C0\u30EB/\u30AA\u30FC\u30D0\u30FC\u30EC\u30A4\u3092\u9589\u3058\u308B\u5FC5\u8981\u304C\u3042\u308B\u5834\u5408\uFF08prerequisiteRef \u5FC5\u9808\uFF09",
+    "- tab_navigation: Tab \u30AD\u30FC\u3067\u30D5\u30A9\u30FC\u30AB\u30B9\u79FB\u52D5\u3057\u3066\u5230\u9054\u3067\u304D\u308B\u5834\u5408",
+    "- not_found: \u672C\u5F53\u306B\u30DA\u30FC\u30B8\u4E0A\u306B\u5BFE\u8C61\u8981\u7D20\u304C\u5B58\u5728\u3057\u306A\u3044\u5834\u5408"
+  ].join("\n");
+  const parts = [
+    "## \u9054\u6210\u3057\u3088\u3046\u3068\u3057\u3066\u3044\u305F\u30B9\u30C6\u30C3\u30D7",
+    `\u8AAC\u660E: ${step.description}`,
+    `\u30A2\u30AF\u30B7\u30E7\u30F3: ${step.action.type}`,
+    `\u30BB\u30EC\u30AF\u30BF\u30D2\u30F3\u30C8: ${JSON.stringify(step.action.selector, null, 2)}`,
+    `URL: ${url}`,
+    "",
+    "## \u3053\u308C\u307E\u3067\u306E\u5931\u6557\u5C65\u6B74",
+    ...failureHistory.map((f, i) => `  ${i + 1}. ${f}`),
+    "",
+    "## \u73FE\u5728\u306E\u30DA\u30FC\u30B8\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\uFF08\u30D5\u30A3\u30EB\u30BF\u6E08\u307F\uFF09",
+    snapshot
+  ];
+  if (contextMarkdown) {
+    parts.push("", "## \u88DC\u8DB3\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8", contextMarkdown);
+  }
+  return { system, userPrompt: parts.join("\n") };
+}
+
+// src/i18n/prompts/en/vision.ts
+function buildVisionMessages(annotations, selector, stepDescription, url, failureHistory) {
+  const system = [
+    "You are a visual selector resolver for browser automation.",
+    "The text-based accessibility tree could not find the element.",
+    "Analyze the screenshot visually to identify the target element.",
+    "",
+    "## How to Read the Screenshot",
+    "- Each interactive element has a red border and number label",
+    "- Number labels are displayed at the top-left of each element",
+    "- Each number corresponds to the number field in the annotation list below",
+    "",
+    "## Matching Guidelines",
+    "1. Infer the type of target element (button, input field, link, etc.) from the step description",
+    "2. Find the element in the screenshot that visually best matches",
+    "3. Use element text, position, and appearance as clues",
+    "4. Also reference the role and name from the annotation list",
+    "5. Target elements not in the A11y tree (canvas, Shadow DOM, iframe, etc.) are also in scope",
+    "6. Return empty string if confidence is low (below 0.5)"
+  ].join("\n");
+  const annotationList = annotations.map((a) => {
+    const nameStr = a.name ? ` "${a.name}"` : "";
+    return `  #${a.number} ref=${a.ref} ${a.role}${nameStr} @(${a.box.x},${a.box.y})`;
+  }).join("\n");
+  const selectorHints = pruneSelectorHints3(selector);
+  const parts = [
+    "## Step Description (Most Important)",
+    stepDescription,
+    "",
+    "## Selector Hints (Reference)",
+    JSON.stringify(selectorHints),
+    "",
+    "## Current URL",
+    url,
+    "",
+    "## Annotation List (Corresponds to Numbers on Screenshot)",
+    annotationList
+  ];
+  if (failureHistory.length > 0) {
+    const recent = failureHistory.slice(-3);
+    parts.push(
+      "",
+      "## Text-based Resolution Failure History (Recent 3)",
+      ...recent.map((f, i) => `  ${i + 1}. ${f}`)
+    );
+  }
+  return { system, userTextContent: parts.join("\n") };
+}
+function pruneSelectorHints3(selector) {
+  const pruned = {};
+  for (const [key, value] of Object.entries(selector)) {
+    if (value === null || value === void 0 || value === "" || value === "unknown" || value === ":") continue;
+    pruned[key] = value;
+  }
+  return pruned;
+}
+
+// src/i18n/prompts/ja/vision.ts
+function buildVisionMessages2(annotations, selector, stepDescription, url, failureHistory) {
+  const system = [
+    "\u3042\u306A\u305F\u306F\u30D6\u30E9\u30A6\u30B6\u81EA\u52D5\u64CD\u4F5C\u306E\u30D3\u30B8\u30E5\u30A2\u30EB\u30BB\u30EC\u30AF\u30BF\u30EA\u30BE\u30EB\u30D0\u30FC\u3067\u3059\u3002",
+    "\u30C6\u30AD\u30B9\u30C8\u30D9\u30FC\u30B9\u306E\u30A2\u30AF\u30BB\u30B7\u30D3\u30EA\u30C6\u30A3\u30C4\u30EA\u30FC\u3067\u306F\u8981\u7D20\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F\u3002",
+    "\u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u3092\u8996\u899A\u7684\u306B\u5206\u6790\u3057\u3066\u3001\u64CD\u4F5C\u5BFE\u8C61\u306E\u8981\u7D20\u3092\u7279\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    "",
+    "## \u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u306E\u898B\u65B9",
+    "- \u5404\u30A4\u30F3\u30BF\u30E9\u30AF\u30C6\u30A3\u30D6\u8981\u7D20\u306B\u8D64\u3044\u67A0\u7DDA\u3068\u756A\u53F7\u30E9\u30D9\u30EB\u304C\u8868\u793A\u3055\u308C\u3066\u3044\u307E\u3059",
+    "- \u756A\u53F7\u30E9\u30D9\u30EB\u306F\u5404\u8981\u7D20\u306E\u5DE6\u4E0A\u306B\u8868\u793A\u3055\u308C\u307E\u3059",
+    "- \u5404\u756A\u53F7\u306F\u4E0B\u8A18\u306E\u30A2\u30CE\u30C6\u30FC\u30B7\u30E7\u30F3\u4E00\u89A7\u306E number \u30D5\u30A3\u30FC\u30EB\u30C9\u306B\u5BFE\u5FDC\u3057\u307E\u3059",
+    "",
+    "## \u30DE\u30C3\u30C1\u30F3\u30B0\u306E\u6307\u91DD",
+    "1. \u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\u304B\u3089\u64CD\u4F5C\u5BFE\u8C61\u306E\u8981\u7D20\u306E\u7A2E\u985E\uFF08\u30DC\u30BF\u30F3\u3001\u5165\u529B\u30D5\u30A3\u30FC\u30EB\u30C9\u3001\u30EA\u30F3\u30AF\u7B49\uFF09\u3092\u63A8\u5B9A",
+    "2. \u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u5185\u3067\u8996\u899A\u7684\u306B\u6700\u3082\u4E00\u81F4\u3059\u308B\u8981\u7D20\u3092\u63A2\u3059",
+    "3. \u8981\u7D20\u306E\u30C6\u30AD\u30B9\u30C8\u3001\u4F4D\u7F6E\u3001\u5916\u89B3\u3092\u624B\u304C\u304B\u308A\u306B\u3059\u308B",
+    "4. \u30A2\u30CE\u30C6\u30FC\u30B7\u30E7\u30F3\u4E00\u89A7\u306E role \u3068 name \u3082\u53C2\u8003\u306B\u3059\u308B",
+    "5. A11y \u30C4\u30EA\u30FC\u306B\u8868\u308C\u306A\u3044\u8981\u7D20\uFF08canvas\u3001Shadow DOM\u3001iframe \u5185\u7B49\uFF09\u3082\u5BFE\u8C61",
+    "6. \u78BA\u4FE1\u5EA6\u304C\u4F4E\u3044\u5834\u5408\uFF080.5\u672A\u6E80\uFF09\u306F\u7A7A\u6587\u5B57\u3092\u8FD4\u3059"
+  ].join("\n");
+  const annotationList = annotations.map((a) => {
+    const nameStr = a.name ? ` "${a.name}"` : "";
+    return `  #${a.number} ref=${a.ref} ${a.role}${nameStr} @(${a.box.x},${a.box.y})`;
+  }).join("\n");
+  const selectorHints = pruneSelectorHints4(selector);
+  const parts = [
+    "## \u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E\uFF08\u6700\u91CD\u8981\uFF09",
+    stepDescription,
+    "",
+    "## \u30BB\u30EC\u30AF\u30BF\u306E\u30D2\u30F3\u30C8\uFF08\u53C2\u8003\u60C5\u5831\uFF09",
+    JSON.stringify(selectorHints),
+    "",
+    "## \u73FE\u5728\u306EURL",
+    url,
+    "",
+    "## \u30A2\u30CE\u30C6\u30FC\u30B7\u30E7\u30F3\u4E00\u89A7\uFF08\u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u4E0A\u306E\u756A\u53F7\u3068\u5BFE\u5FDC\uFF09",
+    annotationList
+  ];
+  if (failureHistory.length > 0) {
+    const recent = failureHistory.slice(-3);
+    parts.push(
+      "",
+      "## \u30C6\u30AD\u30B9\u30C8\u30D9\u30FC\u30B9\u89E3\u6C7A\u306E\u5931\u6557\u5C65\u6B74\uFF08\u76F4\u8FD13\u4EF6\uFF09",
+      ...recent.map((f, i) => `  ${i + 1}. ${f}`)
+    );
+  }
+  return { system, userTextContent: parts.join("\n") };
+}
+function pruneSelectorHints4(selector) {
+  const pruned = {};
+  for (const [key, value] of Object.entries(selector)) {
+    if (value === null || value === void 0 || value === "" || value === "unknown" || value === ":") continue;
+    pruned[key] = value;
+  }
+  return pruned;
+}
+
+// src/i18n/prompts/en/maintenance.ts
+function getSuggestionSystemPrompt() {
+  return [
+    "You are an instruction debugger for browser automation.",
+    "Analyze the failed steps from the debug execution and generate fix suggestions for the instruction and context.",
+    "",
+    "## Fix Suggestion Guidelines",
+    "",
+    "For each failed step, provide suggestions from these two perspectives:",
+    "",
+    "### 1. instructionFix (Instruction YAML Fix)",
+    "- Selector changes (when element has moved/been renamed)",
+    "- Step addition/removal (when the navigation flow has changed)",
+    "- Action value updates (text or URL changes)",
+    "- riskLevel or requiresConfirmation adjustments",
+    `Example: "Step 3: Change selector ariaLabel from 'Submit' to 'Confirm and Submit'"`,
+    "",
+    "### 2. contextFix (Context Markdown Fix)",
+    "- Document page structure changes (new modals, menu structure changes, etc.)",
+    "- Add prerequisites (login state, permissions, environment conditions, etc.)",
+    "- Add selector resolution hints (dynamic ID naming patterns, etc.)",
+    `Example: "Add to context: 'Settings page has changed from tab UI to accordion UI'"`,
+    "",
+    "If context markdown is not provided, return empty string for contextFix.",
+    "",
+    "### severity Criteria",
+    "- error: Selector completely not found, fundamental page structure change",
+    "- warning: Succeeded with retry but unstable, element position or label slightly changed",
+    "",
+    "### failureCategory and suggestedStrategy",
+    "If a failure category is provided, describe a specific fix strategy in suggestedStrategy:",
+    "- element_not_found: Update selector ariaLabel/role/text to match current page structure",
+    "- element_stale: Delete selector cache and re-execute",
+    "- page_structure_changed: Document page structure changes in context.md and update all selectors",
+    "- navigation_timeout: Add wait step or increase step-delay",
+    "- action_failed: Consider changing action type (e.g., click \u2192 hover)",
+    "- unknown: Analyze error details and propose specific remediation"
+  ].join("\n");
+}
+function buildSuggestionUserPrompt(failedInfo, stepsInfo, instruction, contextMarkdown) {
+  const parts = [
+    "## Instruction Information",
+    `Title: ${instruction.title}`,
+    `Goal: ${instruction.metadata.goal}`,
+    `Start URL: ${instruction.metadata.startUrl}`,
+    "",
+    "## Instruction Steps",
+    stepsInfo.join("\n\n"),
+    "",
+    "## Failed Step Details",
+    failedInfo.join("\n\n")
+  ];
+  if (contextMarkdown) {
+    parts.push(
+      "",
+      "## Current Context (markdown)",
+      contextMarkdown
+    );
+  } else {
+    parts.push(
+      "",
+      "## Context",
+      "Context markdown is not provided. Return empty string for contextFix."
+    );
+  }
+  return parts.join("\n");
+}
+
+// src/i18n/prompts/ja/maintenance.ts
+function getSuggestionSystemPrompt2() {
+  return [
+    "\u3042\u306A\u305F\u306F\u30D6\u30E9\u30A6\u30B6\u81EA\u52D5\u64CD\u4F5C\u306E\u6307\u793A\u66F8\u30C7\u30D0\u30C3\u30AC\u30FC\u3067\u3059\u3002",
+    "\u30C7\u30D0\u30C3\u30B0\u5B9F\u884C\u3067\u5931\u6557\u3057\u305F\u30B9\u30C6\u30C3\u30D7\u3092\u5206\u6790\u3057\u3001\u6307\u793A\u66F8\u3068\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\u306E\u4FEE\u6B63\u63D0\u6848\u3092\u751F\u6210\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    "",
+    "## \u4FEE\u6B63\u63D0\u6848\u306E\u6307\u91DD",
+    "",
+    "\u5404\u5931\u6557\u30B9\u30C6\u30C3\u30D7\u306B\u3064\u3044\u3066\u3001\u4EE5\u4E0B\u306E2\u3064\u306E\u89B3\u70B9\u3067\u4FEE\u6B63\u63D0\u6848\u3092\u51FA\u3057\u3066\u304F\u3060\u3055\u3044:",
+    "",
+    "### 1. instructionFix\uFF08\u6307\u793A\u66F8 YAML \u306E\u4FEE\u6B63\uFF09",
+    "- \u30BB\u30EC\u30AF\u30BF\u306E\u5909\u66F4\uFF08\u8981\u7D20\u304C\u79FB\u52D5/\u30EA\u30CD\u30FC\u30E0\u3055\u308C\u305F\u5834\u5408\uFF09",
+    "- \u30B9\u30C6\u30C3\u30D7\u306E\u8FFD\u52A0/\u524A\u9664\uFF08\u5C0E\u7DDA\u304C\u5909\u308F\u3063\u305F\u5834\u5408\uFF09",
+    "- \u30A2\u30AF\u30B7\u30E7\u30F3\u5024\u306E\u66F4\u65B0\uFF08\u30C6\u30AD\u30B9\u30C8\u3084URL\u306E\u5909\u66F4\uFF09",
+    "- riskLevel \u3084 requiresConfirmation \u306E\u8ABF\u6574",
+    "\u4F8B: \u300CStep 3: selector \u306E ariaLabel \u3092 '\u9001\u4FE1' \u2192 '\u78BA\u8A8D\u3057\u3066\u9001\u4FE1' \u306B\u5909\u66F4\u300D",
+    "",
+    "### 2. contextFix\uFF08context markdown \u306E\u4FEE\u6B63\uFF09",
+    "- \u30DA\u30FC\u30B8\u69CB\u9020\u5909\u66F4\u306E\u8A18\u8F09\uFF08\u65B0\u3057\u3044\u30E2\u30FC\u30C0\u30EB\u3001\u30E1\u30CB\u30E5\u30FC\u69CB\u9020\u306E\u5909\u66F4\u306A\u3069\uFF09",
+    "- \u524D\u63D0\u6761\u4EF6\u306E\u8FFD\u52A0\uFF08\u30ED\u30B0\u30A4\u30F3\u72B6\u614B\u3001\u6A29\u9650\u3001\u74B0\u5883\u6761\u4EF6\u306A\u3069\uFF09",
+    "- \u30BB\u30EC\u30AF\u30BF\u89E3\u6C7A\u306E\u30D2\u30F3\u30C8\u8FFD\u52A0\uFF08\u52D5\u7684ID\u306E\u547D\u540D\u898F\u5247\u306A\u3069\uFF09",
+    "\u4F8B: \u300Ccontext \u306B'\u8A2D\u5B9A\u753B\u9762\u304C\u30BF\u30D6UI\u304B\u3089\u30A2\u30B3\u30FC\u30C7\u30A3\u30AA\u30F3UI\u306B\u5909\u66F4\u3055\u308C\u305F'\u65E8\u3092\u8FFD\u8A18\u300D",
+    "",
+    "context markdown \u304C\u672A\u63D0\u4F9B\u306E\u5834\u5408\u3001contextFix \u306F\u7A7A\u6587\u5B57\u3067\u8FD4\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+    "",
+    "### severity \u306E\u5224\u5B9A\u57FA\u6E96",
+    "- error: \u30BB\u30EC\u30AF\u30BF\u304C\u5B8C\u5168\u306B\u898B\u3064\u304B\u3089\u306A\u3044\u3001\u30DA\u30FC\u30B8\u69CB\u9020\u304C\u6839\u672C\u7684\u306B\u5909\u308F\u3063\u3066\u3044\u308B",
+    "- warning: \u30EA\u30C8\u30E9\u30A4\u3067\u6210\u529F\u3057\u305F\u304C\u4E0D\u5B89\u5B9A\u3001\u8981\u7D20\u306E\u4F4D\u7F6E\u3084\u30E9\u30D9\u30EB\u304C\u5FAE\u5999\u306B\u5909\u308F\u3063\u3066\u3044\u308B",
+    "",
+    "### failureCategory \u3068 suggestedStrategy",
+    "\u30A8\u30E9\u30FC\u5206\u985E\u30AB\u30C6\u30B4\u30EA\u304C\u63D0\u4F9B\u3055\u308C\u3066\u3044\u308B\u5834\u5408\u3001\u305D\u308C\u306B\u57FA\u3065\u3044\u3066\u5177\u4F53\u7684\u306A\u4FEE\u6B63\u6226\u7565\u3092 suggestedStrategy \u306B\u8A18\u8F09\u3057\u3066\u304F\u3060\u3055\u3044:",
+    "- element_not_found: \u30BB\u30EC\u30AF\u30BF\u306E ariaLabel/role/text \u3092\u73FE\u5728\u306E\u30DA\u30FC\u30B8\u69CB\u9020\u306B\u5408\u308F\u305B\u3066\u66F4\u65B0",
+    "- element_stale: \u30BB\u30EC\u30AF\u30BF\u30AD\u30E3\u30C3\u30B7\u30E5\u306E\u524A\u9664\u3068\u518D\u5B9F\u884C",
+    "- page_structure_changed: context.md \u306B\u30DA\u30FC\u30B8\u69CB\u9020\u5909\u66F4\u3092\u8A18\u9332\u3057\u3001\u30BB\u30EC\u30AF\u30BF\u3092\u5168\u9762\u66F4\u65B0",
+    "- navigation_timeout: wait \u30B9\u30C6\u30C3\u30D7\u306E\u8FFD\u52A0\u307E\u305F\u306F step-delay \u306E\u5897\u52A0",
+    "- action_failed: \u30A2\u30AF\u30B7\u30E7\u30F3\u7A2E\u5225\u306E\u5909\u66F4\uFF08\u4F8B: click \u2192 hover\uFF09\u3092\u691C\u8A0E",
+    "- unknown: \u30A8\u30E9\u30FC\u5185\u5BB9\u3092\u8A73\u7D30\u306B\u5206\u6790\u3057\u3001\u5177\u4F53\u7684\u306A\u5BFE\u51E6\u3092\u63D0\u6848"
+  ].join("\n");
+}
+function buildSuggestionUserPrompt2(failedInfo, stepsInfo, instruction, contextMarkdown) {
+  const parts = [
+    "## \u6307\u793A\u66F8\u60C5\u5831",
+    `\u30BF\u30A4\u30C8\u30EB: ${instruction.title}`,
+    `\u76EE\u7684: ${instruction.metadata.goal}`,
+    `\u958B\u59CBURL: ${instruction.metadata.startUrl}`,
+    "",
+    "## \u6307\u793A\u66F8\u306E\u30B9\u30C6\u30C3\u30D7\u4E00\u89A7",
+    stepsInfo.join("\n\n"),
+    "",
+    "## \u5931\u6557\u30B9\u30C6\u30C3\u30D7\u306E\u8A73\u7D30",
+    failedInfo.join("\n\n")
+  ];
+  if (contextMarkdown) {
+    parts.push(
+      "",
+      "## \u73FE\u5728\u306E\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\uFF08markdown\uFF09",
+      contextMarkdown
+    );
+  } else {
+    parts.push(
+      "",
+      "## \u30B3\u30F3\u30C6\u30AD\u30B9\u30C8",
+      "context markdown \u306F\u672A\u63D0\u4F9B\u3067\u3059\u3002contextFix \u306F\u7A7A\u6587\u5B57\u3067\u8FD4\u3057\u3066\u304F\u3060\u3055\u3044\u3002"
+    );
+  }
+  return parts.join("\n");
+}
+
+// src/i18n/prompts/index.ts
+function getAgentInstructions3(goal, contextMarkdown, secrets) {
+  return getLocale() === "ja" ? getAgentInstructions2(goal, contextMarkdown, secrets) : getAgentInstructions(goal, contextMarkdown, secrets);
+}
+function getInitialUserMessage3() {
+  return getLocale() === "ja" ? getInitialUserMessage2() : getInitialUserMessage();
+}
+function getReviewSystemPrompt3() {
+  return getLocale() === "ja" ? getReviewSystemPrompt2() : getReviewSystemPrompt();
+}
+function createReviewUserPrompt3(goal, recordedSteps, goalAchieved, interventions) {
+  return getLocale() === "ja" ? createReviewUserPrompt2(goal, recordedSteps, goalAchieved, interventions) : createReviewUserPrompt(goal, recordedSteps, goalAchieved, interventions);
+}
+function buildSelectorMessages3(snapshot, selector, stepDescription, url, contextMarkdown, retryContext, workingMemorySummary) {
+  return getLocale() === "ja" ? buildSelectorMessages2(snapshot, selector, stepDescription, url, contextMarkdown, retryContext, workingMemorySummary) : buildSelectorMessages(snapshot, selector, stepDescription, url, contextMarkdown, retryContext, workingMemorySummary);
+}
+function buildFallbackMessages3(snapshot, step, failureHistory, url, contextMarkdown) {
+  return getLocale() === "ja" ? buildFallbackMessages2(snapshot, step, failureHistory, url, contextMarkdown) : buildFallbackMessages(snapshot, step, failureHistory, url, contextMarkdown);
+}
+function buildVisionMessages3(annotations, selector, stepDescription, url, failureHistory) {
+  return getLocale() === "ja" ? buildVisionMessages2(annotations, selector, stepDescription, url, failureHistory) : buildVisionMessages(annotations, selector, stepDescription, url, failureHistory);
+}
+function getSuggestionSystemPrompt3() {
+  return getLocale() === "ja" ? getSuggestionSystemPrompt2() : getSuggestionSystemPrompt();
+}
+function buildSuggestionUserPrompt3(failedInfo, stepsInfo, instruction, contextMarkdown) {
+  return getLocale() === "ja" ? buildSuggestionUserPrompt2(failedInfo, stepsInfo, instruction, contextMarkdown) : buildSuggestionUserPrompt(failedInfo, stepsInfo, instruction, contextMarkdown);
+}
+
+// src/harness/report-sections.ts
+import { readFile as readFile4 } from "fs/promises";
+async function readDebugLog(filePath) {
+  try {
+    const content = await readFile4(filePath, "utf-8");
+    return content.trim().split("\n").filter((line) => line.trim()).map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return {};
+      }
+    });
+  } catch {
+    return [];
+  }
+}
+function formatAiMetricsSection(aiMetrics) {
+  const lines = [];
+  if (aiMetrics.totalCalls <= 0) return lines;
+  const m = aiMetrics;
+  const totalRealInput = computeTotalRealInput(m);
+  const cacheRate = (computeCacheRate(m) * 100).toFixed(1);
+  lines.push("### AI Metrics");
+  lines.push("");
+  lines.push("| \u30E1\u30C8\u30EA\u30AF\u30B9 | \u5024 |");
+  lines.push("|-----------|-----|");
+  lines.push(`| Total calls | ${m.totalCalls} |`);
+  lines.push(`| Total input tokens | ${totalRealInput.toLocaleString()} |`);
+  lines.push(`| Output tokens | ${m.totalOutputTokens.toLocaleString()} |`);
+  lines.push(`| Cache read tokens | ${m.totalCachedInputTokens.toLocaleString()} |`);
+  lines.push(`| Cache write tokens | ${m.totalCacheCreationTokens.toLocaleString()} |`);
+  lines.push(`| Cache hit rate | ${cacheRate}% |`);
+  lines.push(`| Estimated cost | $${m.estimatedCostUsd.toFixed(4)} |`);
+  lines.push(`| Total AI duration | ${(m.totalDurationMs / 1e3).toFixed(1)}s |`);
+  lines.push("");
+  const cacheHitRate = computeCacheRate(m);
+  if (cacheHitRate < 0.3 && m.totalCalls >= 3) {
+    lines.push(`> **:warning: \u30AD\u30E3\u30C3\u30B7\u30E5\u30D2\u30C3\u30C8\u7387\u304C\u4F4E\u3044 (${cacheRate}%)**`);
+    lines.push("> AI \u30D7\u30ED\u30F3\u30D7\u30C8\u30AD\u30E3\u30C3\u30B7\u30E5\u306E\u6D3B\u7528\u304C\u5C11\u306A\u304F\u3001\u30B3\u30B9\u30C8\u52B9\u7387\u304C\u60AA\u3044\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002");
+    lines.push("> \u8003\u3048\u3089\u308C\u308B\u539F\u56E0: \u30D7\u30ED\u30F3\u30D7\u30C8\u306E\u5148\u982D\u90E8\u5206\u304C\u6BCE\u56DE\u7570\u306A\u308B\u3001\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304C\u5927\u304D\u304F\u5909\u52D5\u3059\u308B\u3001\u540C\u4E00\u30BB\u30EC\u30AF\u30BF\u306E\u518D\u89E3\u6C7A\u304C\u767A\u751F\u3057\u3066\u3044\u306A\u3044\u3002");
+    lines.push("");
+  }
+  if (Object.keys(m.byPurpose).length > 0) {
+    lines.push("**By purpose:**");
+    lines.push("");
+    lines.push("| Purpose | Calls | Input | Output | Cache Read | Cache Write | Duration |");
+    lines.push("|---------|-------|-------|--------|------------|-------------|----------|");
+    for (const [purpose, b] of Object.entries(m.byPurpose)) {
+      const purposeRealInput = computeTotalRealInput(b);
+      lines.push(
+        `| ${purpose} | ${b.calls} | ${purposeRealInput.toLocaleString()} | ${b.outputTokens.toLocaleString()} | ${b.cachedInputTokens.toLocaleString()} | ${b.cacheCreationTokens.toLocaleString()} | ${(b.durationMs / 1e3).toFixed(1)}s |`
+      );
+    }
+    lines.push("");
+  }
+  if (m.byModel && Object.keys(m.byModel).length > 0) {
+    lines.push("**By model:**");
+    lines.push("");
+    lines.push("| Model | Calls | Input | Output | Cache Read | Cache Write | Cost | Duration |");
+    lines.push("|-------|-------|-------|--------|------------|-------------|------|----------|");
+    for (const [modelId, b] of Object.entries(m.byModel)) {
+      const modelRealInput = computeTotalRealInput(b);
+      lines.push(
+        `| ${modelId} | ${b.calls} | ${modelRealInput.toLocaleString()} | ${b.outputTokens.toLocaleString()} | ${b.cachedInputTokens.toLocaleString()} | ${b.cacheCreationTokens.toLocaleString()} | $${b.estimatedCostUsd.toFixed(4)} | ${(b.durationMs / 1e3).toFixed(1)}s |`
+      );
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function formatRuntimeEnvironment() {
+  const lines = [];
+  lines.push("### Runtime Environment");
+  lines.push("");
+  lines.push(`- **AI Model**: ${getModelId()} (${getModelProvider()})`);
+  lines.push(`- **Node.js**: ${process.version}`);
+  lines.push(`- **Platform**: ${process.platform} ${process.arch}`);
+  lines.push("");
+  return lines;
+}
+function formatSelectorResolutionStats(debugEntries, allSteps) {
+  const lines = [];
+  lines.push("### Selector Resolution Statistics");
+  lines.push("");
+  const stepsWithSelector = allSteps.filter(
+    (s) => s.diagnostics?.stepAction?.selector || s.diagnostics?.deterministicResolveResult
+  );
+  const deterministicHits = debugEntries.filter((e) => e.event === "deterministic_resolve").length;
+  const deterministicMisses = debugEntries.filter((e) => e.event === "deterministic_resolve_miss").length;
+  const aiResolves = debugEntries.filter((e) => e.event === "selector_resolve").length;
+  const cacheHits = debugEntries.filter((e) => e.event === "selector_cache_hit").length;
+  const cacheStales = debugEntries.filter((e) => e.event === "selector_cache_stale").length;
+  const retryEvents = debugEntries.filter((e) => e.event === "selector_retry").length;
+  const recoveryAttempts = debugEntries.filter((e) => e.event === "recovery_attempt").length;
+  const agentFallbackStarts = debugEntries.filter((e) => e.event === "agent_fallback_start").length;
+  const agentFallbackResults = debugEntries.filter((e) => e.event === "agent_fallback_result");
+  const agentFallbackSuccesses = agentFallbackResults.filter(
+    (e) => e.data && e.data.success === true
+  ).length;
+  const totalResolveAttempts = deterministicHits + deterministicMisses + cacheHits;
+  if (totalResolveAttempts > 0 || stepsWithSelector.length > 0) {
+    lines.push("| \u30E1\u30C8\u30EA\u30AF\u30B9 | \u4EF6\u6570 |");
+    lines.push("|-----------|------|");
+    if (totalResolveAttempts > 0) {
+      lines.push(`| \u6C7A\u5B9A\u8AD6\u7684\u89E3\u6C7A \u6210\u529F | ${deterministicHits} |`);
+      lines.push(`| \u6C7A\u5B9A\u8AD6\u7684\u89E3\u6C7A \u5931\u6557\u2192AI\u59D4\u8B72 | ${deterministicMisses} |`);
+      lines.push(`| AI \u30BB\u30EC\u30AF\u30BF\u89E3\u6C7A | ${aiResolves} |`);
+      if (cacheHits > 0 || cacheStales > 0) {
+        lines.push(`| \u30AD\u30E3\u30C3\u30B7\u30E5\u30D2\u30C3\u30C8 | ${cacheHits} |`);
+        lines.push(`| \u30AD\u30E3\u30C3\u30B7\u30E5 stale\uFF08\u81EA\u52D5\u7121\u52B9\u5316\uFF09 | ${cacheStales} |`);
+      }
+      lines.push(`| \u30BB\u30EC\u30AF\u30BF\u30EA\u30C8\u30E9\u30A4 | ${retryEvents} |`);
+      if (recoveryAttempts > 0) {
+        lines.push(`| \u30B9\u30AF\u30ED\u30FC\u30EB\u56DE\u5FA9 | ${recoveryAttempts} |`);
+      }
+      const visionFbStarts = debugEntries.filter((e) => e.event === "vision_fallback_start").length;
+      if (visionFbStarts > 0) {
+        const visionFbSuccesses = debugEntries.filter(
+          (e) => e.event === "vision_fallback_result" && e.data && e.data.ref
+        ).length;
+        lines.push(`| Vision Fallback \u767A\u52D5 | ${visionFbStarts} |`);
+        lines.push(`| Vision Fallback \u6210\u529F | ${visionFbSuccesses} |`);
+      }
+      if (agentFallbackStarts > 0) {
+        lines.push(`| Agent Fallback \u767A\u52D5 | ${agentFallbackStarts} |`);
+        lines.push(`| Agent Fallback \u6210\u529F | ${agentFallbackSuccesses} |`);
+      }
+    } else {
+      const totalRetries = allSteps.reduce((sum, s) => sum + (s.retryCount ?? 0), 0);
+      const stepsWithRetry = allSteps.filter((s) => s.retryCount && s.retryCount > 0);
+      lines.push(`| \u30BB\u30EC\u30AF\u30BF\u89E3\u6C7A\u5BFE\u8C61\u30B9\u30C6\u30C3\u30D7 | ${stepsWithSelector.length} |`);
+      lines.push(`| \u30EA\u30C8\u30E9\u30A4\u767A\u751F\u30B9\u30C6\u30C3\u30D7 | ${stepsWithRetry.length} |`);
+      lines.push(`| \u5408\u8A08\u30EA\u30C8\u30E9\u30A4\u56DE\u6570 | ${totalRetries} |`);
+    }
+    lines.push("");
+    if (totalResolveAttempts > 0) {
+      const deterministicRate = deterministicHits + deterministicMisses > 0 ? Math.round(deterministicHits / (deterministicHits + deterministicMisses) * 100) : 0;
+      lines.push(`**\u6C7A\u5B9A\u8AD6\u7684\u89E3\u6C7A\u7387**: ${deterministicRate}% \u2014 `);
+      if (deterministicRate < 50) {
+        lines.push("\u4F4E\u3044\u3002`deterministic-resolver.ts` \u306E\u30D1\u30BF\u30FC\u30F3\u30DE\u30C3\u30C1\u30F3\u30B0\u7CBE\u5EA6\u6539\u5584\u306E\u4F59\u5730\u3042\u308A\u3002");
+      } else if (deterministicRate < 80) {
+        lines.push("\u4E2D\u7A0B\u5EA6\u3002\u983B\u51FA\u306E\u30DE\u30C3\u30C1\u5931\u6557\u30D1\u30BF\u30FC\u30F3\u3092\u5206\u6790\u3057\u8FFD\u52A0\u3059\u308B\u3068 AI \u547C\u3073\u51FA\u3057\u3092\u524A\u6E1B\u3067\u304D\u308B\u3002");
+      } else {
+        lines.push("\u9AD8\u3044\u3002\u6C7A\u5B9A\u8AD6\u7684\u89E3\u6C7A\u304C\u6709\u52B9\u306B\u6A5F\u80FD\u3057\u3066\u3044\u308B\u3002");
+      }
+      lines.push("");
+    }
+  }
+  return lines;
+}
+function formatRetryDistribution(allSteps) {
+  const lines = [];
+  lines.push("### Retry Distribution");
+  lines.push("");
+  const retryDistribution = /* @__PURE__ */ new Map();
+  for (const step of allSteps) {
+    const count = step.retryCount ?? 0;
+    retryDistribution.set(count, (retryDistribution.get(count) ?? 0) + 1);
+  }
+  if (retryDistribution.size > 0) {
+    lines.push("| \u30EA\u30C8\u30E9\u30A4\u56DE\u6570 | \u30B9\u30C6\u30C3\u30D7\u6570 |");
+    lines.push("|-------------|-----------|");
+    for (const [count, steps] of [...retryDistribution.entries()].sort((a, b) => a[0] - b[0])) {
+      lines.push(`| ${count} | ${steps} |`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function getSystemImprovementHint(category) {
+  switch (category) {
+    case "element_not_found":
+      return "\u6C7A\u5B9A\u8AD6\u7684\u89E3\u6C7A\u306E\u30D1\u30BF\u30FC\u30F3\u8FFD\u52A0\u3001\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u30D5\u30A3\u30EB\u30BF\u306E\u898B\u76F4\u3057";
+    case "element_stale":
+      return "\u30AD\u30E3\u30C3\u30B7\u30E5\u7121\u52B9\u5316\u30ED\u30B8\u30C3\u30AF\u306E\u6539\u5584\u3001DOM\u5B89\u5B9A\u5316\u5F85\u6A5F\u306E\u8ABF\u6574";
+    case "page_structure_changed":
+      return "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5DEE\u5206\u691C\u77E5\u306E\u611F\u5EA6\u8ABF\u6574\u3001\u52D5\u7684\u30B3\u30F3\u30C6\u30F3\u30C4\u5BFE\u5FDC";
+    case "navigation_timeout":
+      return "\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3\u5F85\u6A5F\u306E\u6BB5\u968E\u7684\u30BF\u30A4\u30E0\u30A2\u30A6\u30C8\u8ABF\u6574\u3001SPA\u691C\u77E5\u306E\u6539\u5584";
+    case "action_failed":
+      return "\u30A2\u30AF\u30B7\u30E7\u30F3\u30D0\u30EA\u30C7\u30FC\u30B7\u30E7\u30F3\u306E\u7DB2\u7F85\u6027\u5411\u4E0A\u3001role\u4E92\u63DB\u30DE\u30C3\u30D4\u30F3\u30B0\u306E\u62E1\u5145";
+    case "unknown":
+      return "\u30A8\u30E9\u30FC\u5206\u985E\u30ED\u30B8\u30C3\u30AF\u3078\u306E\u65B0\u30AB\u30C6\u30B4\u30EA\u8FFD\u52A0\u3092\u691C\u8A0E";
+    default:
+      return "\u65B0\u3057\u3044\u30AB\u30C6\u30B4\u30EA \u2014 error-classifier.ts \u306B\u8FFD\u52A0\u3092\u691C\u8A0E";
+  }
+}
+function formatFailureCategoryDistribution(failedSteps) {
+  const lines = [];
+  if (failedSteps.length === 0) return lines;
+  lines.push("### Failure Category Distribution");
+  lines.push("");
+  const categoryCount = /* @__PURE__ */ new Map();
+  for (const step of failedSteps) {
+    const cat = step.failureCategory ?? "unclassified";
+    categoryCount.set(cat, (categoryCount.get(cat) ?? 0) + 1);
+  }
+  lines.push("| \u30AB\u30C6\u30B4\u30EA | \u4EF6\u6570 | \u6539\u5584\u30D2\u30F3\u30C8 |");
+  lines.push("|---------|------|-----------|");
+  for (const [cat, count] of [...categoryCount.entries()].sort((a, b) => b[1] - a[1])) {
+    const hint = getSystemImprovementHint(cat);
+    lines.push(`| \`${cat}\` | ${count} | ${hint} |`);
+  }
+  lines.push("");
+  return lines;
+}
+function analyzeRecoveryEffectiveness(entries, allSteps) {
+  const results = [];
+  const retrySteps = allSteps.filter((s) => s.retryCount && s.retryCount > 0);
+  if (retrySteps.length > 0) {
+    const retrySuccesses = retrySteps.filter((s) => s.status === "success").length;
+    results.push({ name: "\u30B9\u30DE\u30FC\u30C8\u30EA\u30C8\u30E9\u30A4", total: retrySteps.length, success: retrySuccesses });
+  }
+  const scrollRecoveries = entries.filter((e) => e.event === "recovery_attempt");
+  if (scrollRecoveries.length > 0) {
+    const scrollStepOrdinals = new Set(scrollRecoveries.map((e) => e.step).filter((s) => s !== void 0));
+    const scrollSuccesses = allSteps.filter(
+      (s) => scrollStepOrdinals.has(s.ordinal) && s.status === "success"
+    ).length;
+    results.push({ name: "\u30B9\u30AF\u30ED\u30FC\u30EB\u56DE\u5FA9", total: scrollRecoveries.length, success: scrollSuccesses });
+  }
+  const visionFallbackStarts = entries.filter((e) => e.event === "vision_fallback_start").length;
+  if (visionFallbackStarts > 0) {
+    const visionSuccesses = entries.filter(
+      (e) => e.event === "vision_fallback_result" && e.data && e.data.ref
+    ).length;
+    results.push({ name: "Vision Fallback", total: visionFallbackStarts, success: visionSuccesses });
+  }
+  const fbStarts = entries.filter((e) => e.event === "agent_fallback_start").length;
+  if (fbStarts > 0) {
+    const fbSuccesses = entries.filter(
+      (e) => e.event === "agent_fallback_result" && e.data && e.data.success === true
+    ).length;
+    results.push({ name: "Agent Fallback", total: fbStarts, success: fbSuccesses });
+  }
+  const deterministicMisses = entries.filter((e) => e.event === "deterministic_resolve_miss");
+  if (deterministicMisses.length > 0) {
+    const missStepOrdinals = new Set(deterministicMisses.map((e) => e.step).filter((s) => s !== void 0));
+    const aiRecoveries = allSteps.filter(
+      (s) => missStepOrdinals.has(s.ordinal) && s.status === "success"
+    ).length;
+    results.push({ name: "AI \u30D5\u30A9\u30FC\u30EB\u30D0\u30C3\u30AF\uFF08\u6C7A\u5B9A\u8AD6\u7684\u5931\u6557\u5F8C\uFF09", total: deterministicMisses.length, success: aiRecoveries });
+  }
+  return results;
+}
+function formatRecoveryEffectiveness(entries, allSteps) {
+  const lines = [];
+  if (entries.length === 0) return lines;
+  const recoveryResults = analyzeRecoveryEffectiveness(entries, allSteps);
+  if (recoveryResults.length === 0) return lines;
+  lines.push("### Recovery Mechanism Effectiveness");
+  lines.push("");
+  lines.push("| \u56DE\u5FA9\u6A5F\u69CB | \u767A\u52D5\u56DE\u6570 | \u6210\u529F | \u5931\u6557 | \u6210\u529F\u7387 |");
+  lines.push("|---------|---------|------|------|--------|");
+  for (const r of recoveryResults) {
+    const rate = r.total > 0 ? Math.round(r.success / r.total * 100) : 0;
+    lines.push(`| ${r.name} | ${r.total} | ${r.success} | ${r.total - r.success} | ${rate}% |`);
+  }
+  lines.push("");
+  return lines;
+}
+function formatPerformanceBottlenecks(allSteps) {
+  const lines = [];
+  const slowSteps = [...allSteps].filter((s) => s.durationMs > 0).sort((a, b) => b.durationMs - a.durationMs).slice(0, 5);
+  if (slowSteps.length > 0 && slowSteps[0].durationMs > 3e3) {
+    lines.push("### Performance Bottlenecks");
+    lines.push("");
+    lines.push("| Step | \u6240\u8981\u6642\u9593 | \u30EA\u30C8\u30E9\u30A4 | \u72B6\u614B | \u8AAC\u660E |");
+    lines.push("|------|---------|---------|------|------|");
+    for (const step of slowSteps) {
+      if (step.durationMs <= 3e3) break;
+      const status = step.status === "failed" ? ":x:" : ":white_check_mark:";
+      lines.push(
+        `| #${step.ordinal} | ${(step.durationMs / 1e3).toFixed(1)}s | ${step.retryCount ?? 0} | ${status} | ${step.description} |`
+      );
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function analyzeAiSelectorQuality(entries) {
+  const issues = [];
+  const aiResponses = entries.filter((e) => e.event === "ai_selector_response");
+  const stepAiCounts = /* @__PURE__ */ new Map();
+  for (const e of aiResponses) {
+    if (e.step !== void 0) {
+      stepAiCounts.set(e.step, (stepAiCounts.get(e.step) ?? 0) + 1);
+    }
+  }
+  for (const [step, count] of stepAiCounts) {
+    if (count > 1) {
+      issues.push({
+        step,
+        description: `AI \u304C ${count} \u56DE\u547C\u3073\u51FA\u3055\u308C\u305F\uFF08\u524D\u56DE\u5FDC\u7B54\u304C\u4E0D\u6B63\u78BA\uFF09\u3002\u30D7\u30ED\u30F3\u30D7\u30C8\u306E\u6539\u5584\u4F59\u5730\u3042\u308A`
+      });
+    }
+  }
+  const unchangedRetries = entries.filter(
+    (e) => e.event === "snapshot_unchanged" && e.data && !e.data.skippingAI
+  );
+  if (unchangedRetries.length > 0) {
+    for (const e of unchangedRetries) {
+      if (e.step !== void 0) {
+        issues.push({
+          step: e.step,
+          description: "\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u672A\u5909\u5316\u306A\u306E\u306B AI \u304C\u518D\u547C\u3073\u51FA\u3057\u3055\u308C\u305F\u3002\u30B9\u30AD\u30C3\u30D7\u30ED\u30B8\u30C3\u30AF\u306E\u78BA\u8A8D\u304C\u5FC5\u8981"
+        });
+      }
+    }
+  }
+  const emptyRefResponses = entries.filter(
+    (e) => e.event === "ai_selector_response" && e.data && typeof e.data.parsedResult === "object" && e.data.parsedResult !== null && e.data.parsedResult.ref === ""
+  );
+  if (emptyRefResponses.length > 0) {
+    const steps = [...new Set(emptyRefResponses.map((e) => e.step).filter((s) => s !== void 0))];
+    for (const step of steps) {
+      issues.push({
+        step,
+        description: "AI \u304C\u7A7A ref \u3092\u8FD4\u3057\u305F\uFF08\u8981\u7D20\u4E0D\u5728\u5224\u5B9A\uFF09\u3002\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u30D5\u30A3\u30EB\u30BF\u304C\u8981\u7D20\u3092\u9664\u53BB\u3057\u3066\u3044\u306A\u3044\u304B\u78BA\u8A8D"
+      });
+    }
+  }
+  return issues;
+}
+function formatAiSelectorQualityIssues(entries) {
+  const lines = [];
+  const aiQualityIssues = analyzeAiSelectorQuality(entries);
+  if (aiQualityIssues.length === 0) return lines;
+  lines.push("### AI Selector Resolution Issues");
+  lines.push("");
+  lines.push("> AI \u30BB\u30EC\u30AF\u30BF\u89E3\u6C7A\u3067\u554F\u984C\u304C\u691C\u51FA\u3055\u308C\u305F\u30B1\u30FC\u30B9\u3002\u30D7\u30ED\u30F3\u30D7\u30C8\u6539\u5584\u306E\u6750\u6599\u3002");
+  lines.push("");
+  for (const issue of aiQualityIssues.slice(0, 5)) {
+    lines.push(`- **Step #${issue.step}**: ${issue.description}`);
+  }
+  lines.push("");
+  return lines;
+}
+var DEFAULT_RECENT_EVENT_TYPES = [
+  "action",
+  "snapshot",
+  "selector_resolve",
+  "selector_retry",
+  "selector_cache_hit",
+  "selector_cache_stale",
+  "deterministic_resolve",
+  "deterministic_resolve_miss",
+  "vision_fallback_start",
+  "vision_fallback_result",
+  "agent_fallback_start",
+  "agent_fallback_result",
+  "recovery_attempt",
+  "extract",
+  "extract_result",
+  "memory_operation"
+];
+function formatDebugLogSections(entries, options = {}) {
+  const lines = [];
+  if (entries.length === 0) return lines;
+  const maxErrors = options.maxErrors ?? 20;
+  const maxRecent = options.maxRecent ?? 15;
+  const recentEventTypes = options.recentEventTypes ?? DEFAULT_RECENT_EVENT_TYPES;
+  if (options.showFailedStepEvents && options.failedOrdinals && options.failedOrdinals.size > 0) {
+    const failedStepEntries = entries.filter(
+      (e) => e.step !== void 0 && options.failedOrdinals.has(e.step)
+    );
+    if (failedStepEntries.length > 0) {
+      lines.push("## Debug Log (Failed Step Events)");
+      lines.push("```json");
+      for (const entry of failedStepEntries.slice(-30)) {
+        lines.push(JSON.stringify(entry));
+      }
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  const errorEntries = entries.filter(
+    (e) => e.event === "error" || e.event === "step_error" || e.event === "validation_failed" || e.data && typeof e.data === "object" && "result" in e.data && typeof e.data.result === "object" && e.data.result !== null && "success" in e.data.result && e.data.result.success === false
+  );
+  if (errorEntries.length > 0) {
+    lines.push("## Debug Log (Error Events)");
+    lines.push("```json");
+    for (const entry of errorEntries.slice(-maxErrors)) {
+      lines.push(JSON.stringify(entry));
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  const actionEntries = entries.filter(
+    (e) => e.event !== void 0 && recentEventTypes.includes(e.event)
+  );
+  const recentActions = actionEntries.slice(-maxRecent);
+  if (recentActions.length > 0) {
+    lines.push("## Debug Log (Recent Events)");
+    lines.push("```json");
+    for (const entry of recentActions) {
+      lines.push(JSON.stringify(entry));
+    }
+    lines.push("```");
+    lines.push("");
+  }
+  return lines;
+}
+
+// src/browser/snapshot-filter.ts
+var KEEP_ROLES = /* @__PURE__ */ new Set([
+  "heading",
+  "navigation",
+  "main",
+  "banner",
+  "form",
+  "dialog",
+  "alertdialog",
+  "alert",
+  "region",
+  "search",
+  "tablist",
+  "tab",
+  "tabpanel",
+  "menu",
+  "menubar",
+  "menuitem",
+  "toolbar",
+  "radiogroup"
+]);
+var NO_COLLAPSE_ROLES = /* @__PURE__ */ new Set([
+  "radio",
+  "checkbox",
+  "option",
+  "tab",
+  "menuitemradio",
+  "menuitemcheckbox",
+  "textbox"
+]);
+var HIDDEN_PATTERNS = [
+  /\[hidden\]/,
+  /\[aria-hidden=true\]/,
+  /\[aria-hidden="true"\]/
+];
+var SEMANTIC_NONE_ROLE_PATTERN = /^\s*(presentation|none)\b/;
+var PAGINATION_TEXT_PATTERN = /\bpage\s+\d+\s+(?:of|\/)\s+\d+\b|\bshowing\s+\d+[\s\-–]+\d+\s+of\s+\d+\b|\d+\s*[\-–]\s*\d+\s+of\s+\d+\b|\d+\s*\/\s*\d+\s*ページ|\d+件中/i;
+function filterSnapshot(snapshot, options) {
+  const lines = snapshot.split("\n");
+  const originalCount = lines.length;
+  const keepIndices = /* @__PURE__ */ new Set();
+  const refPattern = /\[ref=e\d+\]/;
+  const indentStack = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trimStart();
+    const indent = line.length - trimmed.length;
+    while (indentStack.length > 0 && indentStack[indentStack.length - 1].indent >= indent) {
+      indentStack.pop();
+    }
+    indentStack.push({ indent, idx: i });
+    const hasRef = refPattern.test(line);
+    if (hasRef) {
+      keepIndices.add(i);
+      continue;
+    }
+    const roleMatch = trimmed.match(/^(\S+)/);
+    if (roleMatch && KEEP_ROLES.has(roleMatch[1])) {
+      if (!isHiddenLine(line)) {
+        keepIndices.add(i);
+      }
+    }
+    if (!keepIndices.has(i) && PAGINATION_TEXT_PATTERN.test(trimmed)) {
+      if (!isHiddenLine(line)) {
+        keepIndices.add(i);
+      }
+    }
+  }
+  const sortedKeepIndices = [...keepIndices].sort((a, b) => a - b);
+  const collapsedResult = collapseRedundantLists(lines, sortedKeepIndices);
+  const filledSelectors = options?.filledSelectors;
+  if (filledSelectors && filledSelectors.size >= 3) {
+    const filledIndices = [];
+    for (const idx of collapsedResult.keptIndices) {
+      const line = lines[idx];
+      if (!line) continue;
+      const refMatch = line.match(/\[ref=(e\d+)\]/);
+      if (refMatch) {
+        const ref = `@${refMatch[1]}`;
+        if (filledSelectors.has(ref)) {
+          filledIndices.push(idx);
+        }
+      }
+    }
+    if (filledIndices.length >= 3) {
+      const filledSet = new Set(filledIndices);
+      collapsedResult.keptIndices = collapsedResult.keptIndices.filter(
+        (idx) => !filledSet.has(idx)
+      );
+      const firstFilledIdx = filledIndices[0];
+      const firstLine = lines[firstFilledIdx];
+      const indent = firstLine ? Math.floor((firstLine.length - firstLine.trimStart().length) / 2) : 2;
+      collapsedResult.collapseMarkers.push({
+        afterLineIndex: firstFilledIdx > 0 ? firstFilledIdx - 1 : 0,
+        omittedCount: filledIndices.length,
+        indentLevel: indent
+      });
+    }
+  }
+  const parentIndices = /* @__PURE__ */ new Set();
+  for (const idx of collapsedResult.keptIndices) {
+    const line = lines[idx];
+    if (!line) continue;
+    const indent = line.length - line.trimStart().length;
+    if (indent > 0) {
+      for (let j = idx - 1; j >= 0; j--) {
+        const parentLine = lines[j];
+        if (!parentLine) continue;
+        const parentIndent = parentLine.length - parentLine.trimStart().length;
+        if (parentIndent < indent && parentLine.trimStart().length > 0) {
+          parentIndices.add(j);
+          break;
+        }
+      }
+    }
+  }
+  const finalIndices = new Set(collapsedResult.keptIndices);
+  for (const idx of parentIndices) {
+    finalIndices.add(idx);
+  }
+  const filteredLines = [];
+  const finalSorted = [...finalIndices].sort((a, b) => a - b);
+  for (const idx of finalSorted) {
+    const line = lines[idx];
+    if (line.length > 300) {
+      const refMatch = line.match(/\s*\[ref=e\d+\].*$/);
+      if (refMatch) {
+        const refSuffix = refMatch[0];
+        const maxContent = 300 - refSuffix.length - 3;
+        filteredLines.push(
+          maxContent > 0 ? line.slice(0, maxContent) + "..." + refSuffix : line.slice(0, 297) + "..."
+        );
+      } else {
+        filteredLines.push(line.slice(0, 297) + "...");
+      }
+    } else {
+      filteredLines.push(line);
+    }
+  }
+  for (const marker of collapsedResult.collapseMarkers) {
+    const insertAfterIdx = filteredLines.findIndex((_, i) => {
+      const originalIdx = finalSorted[i];
+      return originalIdx !== void 0 && originalIdx >= marker.afterLineIndex;
+    });
+    if (insertAfterIdx >= 0) {
+      const indent = "  ".repeat(marker.indentLevel);
+      filteredLines.splice(insertAfterIdx + 1, 0, `${indent}[... ${marker.omittedCount}\u4EF6\u7701\u7565]`);
+    }
+  }
+  if (filteredLines.length > 300) {
+    const truncatedCount = filteredLines.length;
+    filteredLines.length = 300;
+    filteredLines.push(`[... ${truncatedCount - 300}\u884C\u7701\u7565]`);
+  }
+  const filteredCount = filteredLines.length;
+  const estimatedTokens = Math.ceil(filteredLines.join("\n").length / 4);
+  const meta = `[\u30D5\u30A3\u30EB\u30BF\u6E08\u307F: ${originalCount}\u884C \u2192 ${filteredCount}\u884C, \u63A8\u5B9A ~${estimatedTokens} tokens]`;
+  return `${meta}
+${filteredLines.join("\n")}`;
+}
+function isHiddenLine(line) {
+  return HIDDEN_PATTERNS.some((p2) => p2.test(line)) || SEMANTIC_NONE_ROLE_PATTERN.test(line.trimStart());
+}
+function collapseRedundantLists(lines, sortedIndices) {
+  const keptIndices = [];
+  const collapseMarkers = [];
+  const refPattern = /\[ref=e\d+\]/;
+  const roleCache = /* @__PURE__ */ new Map();
+  function getCachedRole(idx) {
+    let role = roleCache.get(idx);
+    if (role === void 0) {
+      role = extractRole(lines[idx]);
+      roleCache.set(idx, role);
+    }
+    return role;
+  }
+  let i = 0;
+  while (i < sortedIndices.length) {
+    const startIdx = sortedIndices[i];
+    const startLine = lines[startIdx];
+    if (!startLine) {
+      keptIndices.push(startIdx);
+      i++;
+      continue;
+    }
+    if (!refPattern.test(startLine)) {
+      keptIndices.push(startIdx);
+      i++;
+      continue;
+    }
+    const indent = startLine.length - startLine.trimStart().length;
+    const role = getCachedRole(startIdx);
+    if (!role) {
+      keptIndices.push(startIdx);
+      i++;
+      continue;
+    }
+    let runLength = 1;
+    let j = i + 1;
+    while (j < sortedIndices.length) {
+      const nextIdx = sortedIndices[j];
+      const nextLine = lines[nextIdx];
+      if (!nextLine || !refPattern.test(nextLine)) break;
+      const nextIndent = nextLine.length - nextLine.trimStart().length;
+      const nextRole = getCachedRole(nextIdx);
+      if (nextIndent !== indent || nextRole !== role) break;
+      runLength++;
+      j++;
+    }
+    if (runLength >= 3 && !NO_COLLAPSE_ROLES.has(role)) {
+      for (let k = i; k < i + 2; k++) {
+        keptIndices.push(sortedIndices[k]);
+      }
+      collapseMarkers.push({
+        afterLineIndex: sortedIndices[i + 1],
+        omittedCount: runLength - 2,
+        indentLevel: Math.floor(indent / 2)
+      });
+      i = j;
+    } else {
+      for (let k = i; k < j; k++) {
+        keptIndices.push(sortedIndices[k]);
+      }
+      i = j;
+    }
+  }
+  return { keptIndices, collapseMarkers };
+}
+function extractRole(line) {
+  const trimmed = line.trimStart();
+  const cleaned = trimmed.replace(/^-\s+/, "");
+  const roleBeforeRef = cleaned.match(/^(\S+)(?:\s+"[^"]*")?\s*\[ref=e\d+\]/);
+  if (roleBeforeRef) return roleBeforeRef[1];
+  const refFirst = cleaned.match(/\[ref=e\d+\]\s+(\S+)/);
+  if (refFirst) return refFirst[1];
+  const roleMatch = cleaned.match(/^(\S+)/);
+  return roleMatch ? roleMatch[1] : null;
+}
+
+export {
+  loadSecrets,
+  NoopLogger,
+  NoopSpinner,
+  AgentBrowser,
+  filterSnapshot,
+  findElementInSnapshot,
+  parseAllElements,
+  countElements,
+  classifyFailure,
+  getRecoveryHint,
+  noopLogger,
+  createDebugLogger,
+  parseAndAppendToMemory,
+  sleep,
+  getAgentInstructions3 as getAgentInstructions,
+  getInitialUserMessage3 as getInitialUserMessage,
+  getReviewSystemPrompt3 as getReviewSystemPrompt,
+  createReviewUserPrompt3 as createReviewUserPrompt,
+  buildSelectorMessages3 as buildSelectorMessages,
+  buildFallbackMessages3 as buildFallbackMessages,
+  buildVisionMessages3 as buildVisionMessages,
+  getSuggestionSystemPrompt3 as getSuggestionSystemPrompt,
+  buildSuggestionUserPrompt3 as buildSuggestionUserPrompt,
+  InMemoryDataStore,
+  DownloadManager,
+  formatDuration,
+  serializeGeneratorOptions,
+  serializeExecutorOptions,
+  renderOptionsMarkdown,
+  readDebugLog,
+  formatAiMetricsSection,
+  formatRuntimeEnvironment,
+  formatSelectorResolutionStats,
+  formatRetryDistribution,
+  formatFailureCategoryDistribution,
+  formatRecoveryEffectiveness,
+  formatPerformanceBottlenecks,
+  formatAiSelectorQualityIssues,
+  formatDebugLogSections
+};
+//# sourceMappingURL=chunk-U6GPCKY3.js.map