@refrainai/cli 0.4.1

package/dist/chunk-H47NWH7N.js

@@ -0,0 +1,4427 @@
+#!/usr/bin/env node
+import {
+  AgentBrowser,
+  NoopLogger,
+  NoopSpinner,
+  buildFallbackMessages,
+  buildSelectorMessages,
+  buildSuggestionUserPrompt,
+  buildVisionMessages,
+  classifyFailure,
+  countElements,
+  createDebugLogger,
+  findElementInSnapshot,
+  formatDuration,
+  getRecoveryHint,
+  getSuggestionSystemPrompt,
+  parseAllElements,
+  parseAndAppendToMemory,
+  sanitizeBrowserError,
+  sleep
+} from "./chunk-DJVUITRB.js";
+import {
+  filterSnapshot
+} from "./chunk-XMFCXPYU.js";
+import {
+  resolveTemplate
+} from "./chunk-D5SI2PHK.js";
+import {
+  formatRiskHint,
+  getLocale,
+  log,
+  note,
+  promptConfirm,
+  promptSelect,
+  promptText,
+  t,
+  tf
+} from "./chunk-7UCVPKD4.js";
+import {
+  getActiveMetricsCollector,
+  getModel,
+  trackedGenerateObject,
+  withAIRetry
+} from "./chunk-UGPXCQY3.js";
+
+// src/runbook-executor/types.ts
+var SELF_HEAL_DEFAULTS = {
+  enableSelectorCache: true,
+  enableAgentFallback: true,
+  enableVisionFallback: true,
+  maxRetries: 5,
+  retryWarningThreshold: 3
+};
+function applyExecutorDefaults(config) {
+  if (config.selfHeal) {
+    config.enableSelectorCache ??= SELF_HEAL_DEFAULTS.enableSelectorCache;
+    config.enableAgentFallback ??= SELF_HEAL_DEFAULTS.enableAgentFallback;
+    config.enableVisionFallback ??= SELF_HEAL_DEFAULTS.enableVisionFallback;
+    config.maxRetries ??= SELF_HEAL_DEFAULTS.maxRetries;
+    config.retryWarningThreshold ??= SELF_HEAL_DEFAULTS.retryWarningThreshold;
+    config.executionStrategy ??= buildSelfHealStrategy(config.maxRetries);
+    config.skipConfirmation ??= true;
+  }
+}
+function buildSelfHealStrategy(maxRetries) {
+  const changeTimeoutCount = Math.max(maxRetries - 1, 0);
+  const changeTimeouts = [];
+  for (let i = 0; i < changeTimeoutCount; i++) {
+    changeTimeouts.push(8e3 + i * 2e3);
+  }
+  return {
+    maxRetries,
+    changeTimeouts,
+    finalRetryStabilizeMs: 5e3,
+    domStabilityMs: 8e3
+  };
+}
+
+// src/plan/errors.ts
+var PlanLimitError = class extends Error {
+  constructor(message, limitType = "hard") {
+    super(message);
+    this.name = "PlanLimitError";
+    this.limitType = limitType;
+  }
+};
+var PlanFeatureError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlanFeatureError";
+  }
+};
+
+// src/plan/key-kind.ts
+function detectKeyKind(key) {
+  if (key.startsWith("rfn_")) return "opaque";
+  if (key.startsWith("rfnd-")) return "debug";
+  return void 0;
+}
+
+// src/plan/debug-token.ts
+import {
+  createHash,
+  createCipheriv,
+  createDecipheriv,
+  randomBytes,
+  sign,
+  verify,
+  createPublicKey,
+  createPrivateKey
+} from "crypto";
+var DEBUG_PREFIX = "rfnd-";
+var IV_SIZE = 12;
+var AUTH_TAG_SIZE = 16;
+var SIGNATURE_SIZE = 64;
+var EMBEDDED_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEADummyDevPublicKeyForDevelopmentOnly00000000000=
+-----END PUBLIC KEY-----`;
+function deriveAesKey(publicKeyPem) {
+  const publicKey = createPublicKey(publicKeyPem);
+  const rawKey = publicKey.export({ type: "spki", format: "der" });
+  return createHash("sha256").update(rawKey).digest();
+}
+function generateDebugToken(tenantId, privateKeyPem, publicKeyPem) {
+  if (!tenantId) {
+    throw new Error("tenantId is required");
+  }
+  const payload = {
+    tid: tenantId,
+    iat: Math.floor(Date.now() / 1e3)
+  };
+  const payloadBytes = Buffer.from(JSON.stringify(payload), "utf-8");
+  const privateKey = createPrivateKey(privateKeyPem);
+  const signature = sign(null, payloadBytes, privateKey);
+  if (signature.length !== SIGNATURE_SIZE) {
+    throw new Error(`Unexpected Ed25519 signature size: ${signature.length}`);
+  }
+  const plaintext = Buffer.concat([payloadBytes, signature]);
+  const aesKey = deriveAesKey(publicKeyPem);
+  const iv = randomBytes(IV_SIZE);
+  const cipher = createCipheriv("aes-256-gcm", aesKey, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  const combined = Buffer.concat([iv, encrypted, authTag]);
+  return `${DEBUG_PREFIX}${combined.toString("base64url")}`;
+}
+function verifyDebugToken(token, publicKeyPemOverride) {
+  if (!token.startsWith(DEBUG_PREFIX)) return void 0;
+  const publicKeyPem = publicKeyPemOverride ?? getDebugPublicKey();
+  try {
+    const combined = Buffer.from(token.slice(DEBUG_PREFIX.length), "base64url");
+    if (combined.length < IV_SIZE + 1 + AUTH_TAG_SIZE) return void 0;
+    const iv = combined.subarray(0, IV_SIZE);
+    const authTag = combined.subarray(combined.length - AUTH_TAG_SIZE);
+    const encrypted = combined.subarray(IV_SIZE, combined.length - AUTH_TAG_SIZE);
+    const aesKey = deriveAesKey(publicKeyPem);
+    const decipher = createDecipheriv("aes-256-gcm", aesKey, iv);
+    decipher.setAuthTag(authTag);
+    const plaintext = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    if (plaintext.length <= SIGNATURE_SIZE) return void 0;
+    const payloadBytes = plaintext.subarray(0, plaintext.length - SIGNATURE_SIZE);
+    const signature = plaintext.subarray(plaintext.length - SIGNATURE_SIZE);
+    const publicKey = createPublicKey(publicKeyPem);
+    const valid = verify(null, payloadBytes, publicKey, signature);
+    if (!valid) return void 0;
+    const payload = JSON.parse(payloadBytes.toString("utf-8"));
+    if (typeof payload.tid !== "string" || !payload.tid) return void 0;
+    if (typeof payload.iat !== "number") return void 0;
+    return {
+      tenantId: payload.tid,
+      issuedAt: new Date(payload.iat * 1e3)
+    };
+  } catch {
+    return void 0;
+  }
+}
+function getDebugSigningKey() {
+  return process.env.REFRAIN_DEBUG_SIGNING_KEY;
+}
+function getDebugPublicKey() {
+  return process.env.REFRAIN_DEBUG_PUBLIC_KEY ?? EMBEDDED_PUBLIC_KEY_PEM;
+}
+
+// src/plan/key-cache.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var CONFIG_DIR = join(homedir(), ".config", "refrain");
+var CACHE_FILE = join(CONFIG_DIR, "key-cache.json");
+function hashKey(apiKey) {
+  return createHash2("sha256").update(apiKey).digest("hex");
+}
+async function loadCacheFile() {
+  try {
+    const data = await readFile(CACHE_FILE, "utf-8");
+    const parsed = JSON.parse(data);
+    if (parsed.version === 1 && parsed.entries) return parsed;
+    return { version: 1, entries: {} };
+  } catch {
+    return { version: 1, entries: {} };
+  }
+}
+async function saveCacheFile(cache) {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+}
+async function getCachedKey(apiKey, allowExpired = false) {
+  const cache = await loadCacheFile();
+  const hash = hashKey(apiKey);
+  const entry = cache.entries[hash];
+  if (!entry) return void 0;
+  const now = /* @__PURE__ */ new Date();
+  const expires = new Date(entry.expiresAt);
+  if (!allowExpired && expires <= now) {
+    delete cache.entries[hash];
+    await saveCacheFile(cache);
+    return void 0;
+  }
+  return entry;
+}
+async function setCachedKey(apiKey, data) {
+  const cache = await loadCacheFile();
+  const hash = hashKey(apiKey);
+  cache.entries[hash] = data;
+  await saveCacheFile(cache);
+}
+
+// src/plan/key-validator.ts
+var DEFAULT_SERVER_URL = "https://api.therefrain.ai";
+async function validateOpaqueKey(apiKey, serverUrl, forceRefresh = false) {
+  if (!forceRefresh) {
+    const cached = await getCachedKey(apiKey);
+    if (cached) {
+      return planFromCachedData(cached);
+    }
+  }
+  const baseUrl = serverUrl ?? process.env.REFRAIN_API_SERVER_URL ?? DEFAULT_SERVER_URL;
+  try {
+    const response = await fetch(`${baseUrl}/api/public/validate-key`, {
+      headers: {
+        Authorization: `Bearer ${apiKey}`
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      if (data.valid && data.tier && data.tenantId) {
+        const basePlan = TIER_TO_PLAN[data.tier] ?? COMMUNITY_PLAN;
+        const plan = {
+          ...basePlan,
+          tenantId: data.tenantId,
+          // サーバーが limits/features を返した場合はそれを使用
+          ...data.limits ? { limits: data.limits } : {},
+          ...data.features ? { features: data.features } : {}
+        };
+        const cacheData = {
+          tier: data.tier,
+          tenantId: data.tenantId,
+          limits: plan.limits,
+          features: plan.features,
+          expiresAt: data.expiresAt ?? new Date(Date.now() + 24 * 60 * 60 * 1e3).toISOString()
+        };
+        await setCachedKey(apiKey, cacheData);
+        return plan;
+      }
+    }
+    return COMMUNITY_PLAN;
+  } catch {
+    return offlineFallback(apiKey);
+  }
+}
+async function offlineFallback(apiKey) {
+  const expired = await getCachedKey(apiKey, true);
+  if (expired) {
+    console.warn(
+      "[refrain] Warning: Using expired key cache (offline mode). Connect to the API server to refresh."
+    );
+    return planFromCachedData(expired);
+  }
+  console.warn(
+    "[refrain] Warning: Cannot validate API key (offline, no cache). Falling back to Community plan."
+  );
+  return COMMUNITY_PLAN;
+}
+function planFromCachedData(data) {
+  const basePlan = TIER_TO_PLAN[data.tier] ?? COMMUNITY_PLAN;
+  return {
+    ...basePlan,
+    tenantId: data.tenantId,
+    limits: data.limits,
+    features: data.features
+  };
+}
+
+// src/plan/index.ts
+var COMMUNITY_PLAN = {
+  tier: "community",
+  limits: {
+    maxStepsPerRunbook: 100,
+    maxBatchRows: 20,
+    maxConcurrentJobs: Number.POSITIVE_INFINITY,
+    maxMonthlyJobs: Number.POSITIVE_INFINITY,
+    maxMonthlySteps: 300,
+    maxJobDurationMs: 10 * 60 * 1e3,
+    // 10 minutes
+    maxStepDurationMs: Number.POSITIVE_INFINITY,
+    maxVideoRecordings: 0,
+    maxScreenshots: 10,
+    maxRunbookVersions: 1
+  },
+  features: {
+    selectorCache: false,
+    agentFallback: true,
+    visionFallback: false,
+    selfHealMode: false,
+    hitl: false,
+    modelOverrides: false,
+    remoteExecution: false,
+    stealthMode: false,
+    screenshotSave: true,
+    videoRecording: false,
+    scheduling: false,
+    skills: false,
+    samlSso: false,
+    auditLog: false,
+    runbookApprovalWorkflow: false,
+    runbookRollback: false
+  }
+};
+var PRO_PLAN = {
+  tier: "pro",
+  limits: {
+    maxStepsPerRunbook: 500,
+    maxBatchRows: 100,
+    maxConcurrentJobs: Number.POSITIVE_INFINITY,
+    maxMonthlyJobs: Number.POSITIVE_INFINITY,
+    maxMonthlySteps: 1500,
+    maxJobDurationMs: 30 * 60 * 1e3,
+    // 30 minutes
+    maxStepDurationMs: Number.POSITIVE_INFINITY,
+    maxVideoRecordings: 0,
+    maxScreenshots: 0,
+    maxRunbookVersions: 1
+  },
+  features: {
+    selectorCache: true,
+    agentFallback: true,
+    visionFallback: true,
+    selfHealMode: false,
+    hitl: false,
+    modelOverrides: false,
+    remoteExecution: false,
+    stealthMode: true,
+    screenshotSave: false,
+    videoRecording: false,
+    scheduling: false,
+    skills: true,
+    samlSso: false,
+    auditLog: false,
+    runbookApprovalWorkflow: false,
+    runbookRollback: false
+  }
+};
+var TEAM_PLAN = {
+  tier: "team",
+  limits: {
+    maxStepsPerRunbook: Number.POSITIVE_INFINITY,
+    maxBatchRows: 500,
+    maxConcurrentJobs: 10,
+    maxMonthlyJobs: 2e3,
+    maxMonthlySteps: 8e3,
+    maxJobDurationMs: 2 * 60 * 60 * 1e3,
+    // 2 hours
+    maxStepDurationMs: 5 * 60 * 1e3,
+    // 5 minutes
+    maxVideoRecordings: 0,
+    maxScreenshots: 100,
+    maxRunbookVersions: 1
+  },
+  features: {
+    selectorCache: true,
+    agentFallback: true,
+    visionFallback: true,
+    selfHealMode: true,
+    hitl: false,
+    modelOverrides: false,
+    remoteExecution: true,
+    stealthMode: true,
+    screenshotSave: true,
+    videoRecording: false,
+    scheduling: true,
+    skills: true,
+    samlSso: false,
+    auditLog: false,
+    runbookApprovalWorkflow: false,
+    runbookRollback: false
+  }
+};
+var BUSINESS_PLAN = {
+  tier: "business",
+  limits: {
+    maxStepsPerRunbook: Number.POSITIVE_INFINITY,
+    maxBatchRows: 1e3,
+    maxConcurrentJobs: 50,
+    maxMonthlyJobs: 5e3,
+    maxMonthlySteps: 2e4,
+    maxJobDurationMs: 4 * 60 * 60 * 1e3,
+    // 4 hours
+    maxStepDurationMs: 5 * 60 * 1e3,
+    // 5 minutes
+    maxVideoRecordings: 10,
+    maxScreenshots: 500,
+    maxRunbookVersions: 10
+  },
+  features: {
+    selectorCache: true,
+    agentFallback: true,
+    visionFallback: true,
+    selfHealMode: true,
+    hitl: true,
+    modelOverrides: true,
+    remoteExecution: true,
+    stealthMode: true,
+    screenshotSave: true,
+    videoRecording: true,
+    scheduling: true,
+    skills: true,
+    samlSso: false,
+    auditLog: false,
+    runbookApprovalWorkflow: true,
+    runbookRollback: true
+  }
+};
+var ENTERPRISE_PLAN = {
+  tier: "enterprise",
+  limits: {
+    maxStepsPerRunbook: Number.POSITIVE_INFINITY,
+    maxBatchRows: Number.POSITIVE_INFINITY,
+    maxConcurrentJobs: Number.POSITIVE_INFINITY,
+    maxMonthlyJobs: Number.POSITIVE_INFINITY,
+    maxMonthlySteps: Number.POSITIVE_INFINITY,
+    maxJobDurationMs: 24 * 60 * 60 * 1e3,
+    // 24 hours
+    maxStepDurationMs: 10 * 60 * 1e3,
+    // 10 minutes
+    maxVideoRecordings: Number.POSITIVE_INFINITY,
+    maxScreenshots: Number.POSITIVE_INFINITY,
+    maxRunbookVersions: Number.POSITIVE_INFINITY
+  },
+  features: {
+    selectorCache: true,
+    agentFallback: true,
+    visionFallback: true,
+    selfHealMode: true,
+    hitl: true,
+    modelOverrides: true,
+    remoteExecution: true,
+    stealthMode: true,
+    screenshotSave: true,
+    videoRecording: true,
+    scheduling: true,
+    skills: true,
+    samlSso: true,
+    auditLog: true,
+    runbookApprovalWorkflow: true,
+    runbookRollback: true
+  }
+};
+var PLAN_PRICING = {
+  community: 0,
+  pro: 55,
+  team: 269,
+  business: 499,
+  enterprise: null
+};
+var TIER_TO_PLAN = {
+  community: COMMUNITY_PLAN,
+  pro: PRO_PLAN,
+  team: TEAM_PLAN,
+  business: BUSINESS_PLAN,
+  enterprise: ENTERPRISE_PLAN
+};
+function resolvePlanFromTier(tier, tenantId) {
+  const basePlan = TIER_TO_PLAN[tier] ?? COMMUNITY_PLAN;
+  return { ...basePlan, tenantId };
+}
+async function resolvePlan(apiKey, options) {
+  if (!apiKey) return COMMUNITY_PLAN;
+  const kind = detectKeyKind(apiKey);
+  if (!kind) return COMMUNITY_PLAN;
+  if (kind === "debug") {
+    const verified = verifyDebugToken(apiKey);
+    if (!verified) return COMMUNITY_PLAN;
+    return { ...ENTERPRISE_PLAN, tenantId: verified.tenantId };
+  }
+  return validateOpaqueKey(apiKey, options?.serverUrl, options?.forceRefresh);
+}
+function getApiKey(cliValue) {
+  return cliValue ?? process.env.REFRAIN_API_KEY;
+}
+function enforceFeatureGates(config, plan) {
+  config.enableSelectorCache ??= plan.features.selectorCache;
+  config.enableAgentFallback ??= plan.features.agentFallback;
+  config.enableVisionFallback ??= plan.features.visionFallback;
+  if (!plan.features.selectorCache) config.enableSelectorCache = false;
+  if (!plan.features.agentFallback) config.enableAgentFallback = false;
+  if (!plan.features.visionFallback) config.enableVisionFallback = false;
+  if (!plan.features.selfHealMode && config.selfHeal) {
+    throw new PlanFeatureError(
+      "Self-healing mode requires a Team plan. Upgrade: https://therefrain.ai/pricing"
+    );
+  }
+  if (!plan.features.hitl) {
+    if (config.approvalMode && config.approvalMode !== "web") {
+      throw new PlanFeatureError(
+        `${config.approvalMode} approval requires a Business plan. Upgrade: https://therefrain.ai/pricing`
+      );
+    }
+    if (config.notifyMode) {
+      throw new PlanFeatureError(
+        `${config.notifyMode} notification requires a Business plan. Upgrade: https://therefrain.ai/pricing`
+      );
+    }
+  }
+  if (!plan.features.modelOverrides && config.aiModelConfig?.modelOverrides) {
+    config.aiModelConfig.modelOverrides = void 0;
+  }
+  if (!plan.features.screenshotSave && config.screenshotDir) {
+    throw new PlanFeatureError(
+      "Screenshot saving requires a Team plan (or Community tier for evaluation). Upgrade: https://therefrain.ai/pricing"
+    );
+  }
+  if (!plan.features.videoRecording && config.videoDir) {
+    throw new PlanFeatureError(
+      "Video recording requires a Business plan. Upgrade: https://therefrain.ai/pricing"
+    );
+  }
+  if (!plan.features.skills && config.skills?.length) {
+    throw new PlanFeatureError(
+      "Skills require a Pro plan. Upgrade: https://therefrain.ai/pricing"
+    );
+  }
+  if (!plan.features.stealthMode) {
+    if (config.stealth) {
+      throw new PlanFeatureError(
+        "Stealth mode requires a Pro plan. Upgrade: https://therefrain.ai/pricing"
+      );
+    }
+    if (config.proxy) {
+      throw new PlanFeatureError(
+        "Proxy support requires a Pro plan. Upgrade: https://therefrain.ai/pricing"
+      );
+    }
+  }
+}
+function validateStepLimit(stepCount, plan) {
+  if (stepCount > plan.limits.maxStepsPerRunbook) {
+    throw new PlanLimitError(
+      `This runbook has ${stepCount} steps, but your plan allows up to ${plan.limits.maxStepsPerRunbook}. Upgrade: https://therefrain.ai/pricing`
+    );
+  }
+}
+function validateBatchLimit(rowCount, plan) {
+  if (rowCount > plan.limits.maxBatchRows) {
+    throw new PlanLimitError(
+      `Batch has ${rowCount} rows, but your plan allows up to ${plan.limits.maxBatchRows}. Upgrade: https://therefrain.ai/pricing`
+    );
+  }
+}
+function formatPlanLabel(plan) {
+  const stepsLabel = plan.limits.maxStepsPerRunbook === Number.POSITIVE_INFINITY ? "unlimited" : `${plan.limits.maxStepsPerRunbook} steps`;
+  const batchLabel = plan.limits.maxBatchRows === Number.POSITIVE_INFINITY ? "unlimited" : `${plan.limits.maxBatchRows} batch rows`;
+  const monthlyLabel = plan.limits.maxMonthlySteps === Number.POSITIVE_INFINITY ? "unlimited" : `${plan.limits.maxMonthlySteps.toLocaleString("en-US")}/mo`;
+  return `${plan.tier.charAt(0).toUpperCase() + plan.tier.slice(1)} (${stepsLabel}, ${batchLabel}, ${monthlyLabel})`;
+}
+
+// src/harness/selector-cache.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync } from "fs";
+import { createHash as createHash3 } from "crypto";
+import { join as join2, dirname, basename } from "path";
+function buildCacheKey(stepOrdinal, url, selector) {
+  const selectorHash = createHash3("sha256").update(JSON.stringify(selector)).digest("hex").slice(0, 12);
+  const urlNormalized = url.split("?")[0];
+  return `${stepOrdinal}:${urlNormalized}:${selectorHash}`;
+}
+function buildSnapshotHash(snapshot) {
+  return createHash3("sha256").update(snapshot).digest("hex").slice(0, 16);
+}
+function cacheFilePath(runbookPath) {
+  const dir = dirname(runbookPath);
+  const base = basename(runbookPath, ".yaml");
+  return join2(dir, `${base}.selector-cache.json`);
+}
+async function loadCache(runbookPath) {
+  const path = cacheFilePath(runbookPath);
+  if (!existsSync(path)) {
+    return { version: 1, runbookPath, entries: {} };
+  }
+  try {
+    const raw = await readFile2(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    parsed.runbookPath = runbookPath;
+    return parsed;
+  } catch {
+    return { version: 1, runbookPath, entries: {} };
+  }
+}
+async function saveCache(cache) {
+  const path = cacheFilePath(cache.runbookPath);
+  try {
+    await writeFile2(path, JSON.stringify(cache, null, 2), "utf-8");
+  } catch {
+  }
+}
+function lookupCache(cache, key) {
+  return cache.entries[key];
+}
+function updateCache(cache, key, ref, snapshotHash) {
+  const existing = cache.entries[key];
+  cache.entries[key] = {
+    ref,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    snapshotHash,
+    hitCount: (existing?.hitCount ?? 0) + 1
+  };
+}
+function invalidateCacheEntry(cache, key) {
+  delete cache.entries[key];
+}
+
+// src/runbook-executor/executor.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
+
+// src/harness/selector-resolver.ts
+import { z } from "zod";
+var selectorResponseSchema = z.object({
+  reasoning: z.string().describe("\u30DE\u30C3\u30C1\u30F3\u30B0\u5224\u65AD\u306E\u7406\u7531\u30921-2\u6587\u3067\u8AAC\u660E"),
+  ref: z.string().describe("\u30DE\u30C3\u30C1\u3057\u305F\u8981\u7D20\u306Eref\u5024\uFF08\u4F8B: e3\uFF09\u3002@\u306F\u542B\u3081\u306A\u3044\u3002\u8A72\u5F53\u8981\u7D20\u304C\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5185\u306B\u5B58\u5728\u3057\u306A\u3044\u5834\u5408\u306F\u7A7A\u6587\u5B57")
+});
+async function resolveImpl(snapshot, selector, stepDescription, url, contextMarkdown, debugLogger, retryContext, workingMemorySummary, aiProvider) {
+  const { system, userPrompt } = buildSelectorMessages(snapshot, selector, stepDescription, url, contextMarkdown, retryContext, workingMemorySummary);
+  const prompt = `${system}
+---
+${userPrompt}`;
+  debugLogger?.log({
+    phase: "executor",
+    event: "ai_selector_prompt",
+    data: { prompt, selector, stepDescription, url }
+  });
+  const model = aiProvider ? aiProvider.getModel("selector") : getModel("selector");
+  const { object } = await withAIRetry(
+    () => trackedGenerateObject("selector", {
+      model,
+      messages: [
+        {
+          role: "system",
+          content: system,
+          providerOptions: {
+            anthropic: { cacheControl: { type: "ephemeral" } }
+          }
+        },
+        { role: "user", content: userPrompt }
+      ],
+      schema: selectorResponseSchema,
+      temperature: 0
+    }),
+    { label: "selector-resolve" }
+  );
+  debugLogger?.log({
+    phase: "executor",
+    event: "ai_selector_response",
+    data: { parsedResult: object }
+  });
+  return { ref: object.ref ?? "", aiResponseText: JSON.stringify(object), reasoning: object.reasoning, prompt };
+}
+async function resolveWithAIDetailed(snapshot, selector, stepDescription, url, contextMarkdown, debugLogger, retryContext, workingMemorySummary, aiProvider) {
+  return resolveImpl(snapshot, selector, stepDescription, url, contextMarkdown, debugLogger, retryContext, workingMemorySummary, aiProvider);
+}
+
+// src/harness/failure-registry.ts
+var MAX_PATTERNS = 50;
+var FailureRegistry = class {
+  constructor() {
+    this.patterns = [];
+  }
+  /**
+   * 失敗を記録する。
+   * 同じ urlPattern + selectorHint + category の組み合わせは count をインクリメント。
+   */
+  record(url, selector, category, stepOrdinal, resolution) {
+    const urlPattern = normalizeUrlPattern(url);
+    const selectorHint = buildSelectorHint(selector);
+    const existing = this.patterns.find(
+      (p) => p.urlPattern === urlPattern && p.selectorHint === selectorHint && p.category === category
+    );
+    if (existing) {
+      existing.count++;
+      existing.lastStepOrdinal = stepOrdinal;
+      if (resolution) {
+        existing.recoveryUsed = resolution.method;
+      }
+    } else {
+      if (this.patterns.length >= MAX_PATTERNS) {
+        this.patterns.shift();
+      }
+      this.patterns.push({
+        urlPattern,
+        selectorHint,
+        category,
+        recoveryUsed: resolution?.method,
+        count: 1,
+        lastStepOrdinal: stepOrdinal
+      });
+    }
+  }
+  /**
+   * URL + セレクタに関連する回復ヒントを返す。
+   * 類似パターンがなければ undefined。
+   */
+  getRelevantHints(url, selector) {
+    const urlPattern = normalizeUrlPattern(url);
+    const selectorHint = buildSelectorHint(selector);
+    const relevant = this.patterns.filter(
+      (p) => p.urlPattern === urlPattern || p.selectorHint === selectorHint
+    );
+    if (relevant.length === 0) return void 0;
+    const recoveryMethods = /* @__PURE__ */ new Map();
+    for (const p of relevant) {
+      if (p.recoveryUsed) {
+        recoveryMethods.set(
+          p.recoveryUsed,
+          (recoveryMethods.get(p.recoveryUsed) ?? 0) + p.count
+        );
+      }
+    }
+    const parts = [];
+    const categoryCounts = /* @__PURE__ */ new Map();
+    for (const p of relevant) {
+      categoryCounts.set(p.category, (categoryCounts.get(p.category) ?? 0) + p.count);
+    }
+    const categoryStr = [...categoryCounts.entries()].map(([cat, count]) => `${cat}(${count}x)`).join(", ");
+    parts.push(`Similar failures on ${urlPattern}: ${categoryStr}`);
+    if (recoveryMethods.size > 0) {
+      const recoveryStr = [...recoveryMethods.entries()].sort((a, b) => b[1] - a[1]).map(([method, count]) => `${method}(${count}x)`).join(", ");
+      parts.push(`Resolved by: ${recoveryStr}`);
+    }
+    return parts.join(". ");
+  }
+  /** 蓄積パターン数 */
+  get size() {
+    return this.patterns.length;
+  }
+  /** パターンをクリア */
+  clear() {
+    this.patterns = [];
+  }
+};
+function normalizeUrlPattern(url) {
+  try {
+    const parsed = new URL(url);
+    const normalizedPath = parsed.pathname.split("/").map((segment) => {
+      if (/^\d+$/.test(segment)) return "*";
+      if (/^[0-9a-f]{8,}$/i.test(segment)) return "*";
+      return segment;
+    }).join("/");
+    return `${parsed.hostname}${normalizedPath}`;
+  } catch {
+    return url;
+  }
+}
+function buildSelectorHint(selector) {
+  const parts = [];
+  if (selector.role) parts.push(`role:${selector.role}`);
+  if (selector.name) parts.push(`name:${selector.name}`);
+  if (selector.ariaLabel) parts.push(`aria:${selector.ariaLabel}`);
+  if (selector.dataTestId) parts.push(`testid:${selector.dataTestId}`);
+  return parts.join("|") || "unknown";
+}
+
+// src/harness/goal-agent.ts
+import { z as z2 } from "zod";
+var agentFallbackSchema = z2.object({
+  analysis: z2.string().describe("\u30DA\u30FC\u30B8\u306E\u73FE\u72B6\u306E\u5206\u6790\uFF08200\u5B57\u4EE5\u5185\uFF09"),
+  alternativeRef: z2.string().describe(
+    "\u4EE3\u66FF\u3068\u306A\u308B\u64CD\u4F5C\u5BFE\u8C61\u8981\u7D20\u306Eref\u5024\uFF08\u4F8B: e5\uFF09\u3002@\u306F\u542B\u3081\u306A\u3044\u3002\u898B\u3064\u304B\u3089\u306A\u3044\u5834\u5408\u306F\u7A7A\u6587\u5B57\u3002"
+  ),
+  alternativeStrategy: z2.enum([
+    "direct_ref",
+    "scroll_up_and_retry",
+    "expand_collapsed",
+    "dismiss_overlay",
+    "tab_navigation",
+    "not_found"
+  ]).describe("\u63A8\u5968\u3059\u308B\u4EE3\u66FF\u6226\u7565"),
+  prerequisiteRef: z2.string().optional().describe(
+    "alternativeStrategy \u304C expand_collapsed/dismiss_overlay \u306E\u5834\u5408: \u5148\u306B\u64CD\u4F5C\u3059\u308B\u8981\u7D20\u306Eref"
+  ),
+  reasoning: z2.string().describe("\u4EE3\u66FF\u30D1\u30B9\u3092\u9078\u3093\u3060\u7406\u7531\uFF08100\u5B57\u4EE5\u5185\uFF09")
+});
+async function runGoalAgent(browser, step, failureHistory, contextMarkdown, debugLogger, aiProvider) {
+  try {
+    await browser.scroll("up", 2e3);
+    await browser.waitForDOMStability(3e3);
+  } catch {
+  }
+  const fullSnapshot = filterSnapshot(await browser.snapshot());
+  const currentUrl = await browser.url();
+  const { system, userPrompt } = buildFallbackMessages(
+    fullSnapshot,
+    step,
+    failureHistory,
+    currentUrl,
+    contextMarkdown
+  );
+  try {
+    const model = aiProvider ? aiProvider.getModel("fallback") : getModel("fallback");
+    const { object } = await trackedGenerateObject("fallback", {
+      model,
+      messages: [
+        {
+          role: "system",
+          content: system,
+          providerOptions: {
+            anthropic: { cacheControl: { type: "ephemeral" } }
+          }
+        },
+        { role: "user", content: userPrompt }
+      ],
+      schema: agentFallbackSchema,
+      temperature: 0.3
+    });
+    if (object.alternativeStrategy === "not_found" || !object.alternativeRef) {
+      return { ...object, alternativeRef: object.alternativeRef ?? "", success: false };
+    }
+    if (object.prerequisiteRef && (object.alternativeStrategy === "expand_collapsed" || object.alternativeStrategy === "dismiss_overlay")) {
+      debugLogger?.log({
+        phase: "executor",
+        event: "agent_fallback_prerequisite",
+        data: {
+          strategy: object.alternativeStrategy,
+          prerequisiteRef: object.prerequisiteRef
+        }
+      });
+      try {
+        await browser.click(`@${object.prerequisiteRef}`);
+        await browser.waitForDOMStability(2e3);
+      } catch {
+        return { ...object, alternativeRef: object.alternativeRef ?? "", success: false };
+      }
+      const updatedSnapshot = await browser.snapshot();
+      if (findElementInSnapshot(updatedSnapshot, object.alternativeRef) === null) {
+        return { ...object, success: false };
+      }
+    }
+    return { ...object, success: true };
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[goal-agent] Agent fallback AI call failed: ${msg}`);
+    return {
+      analysis: "AI\u547C\u3073\u51FA\u3057\u306B\u5931\u6557",
+      alternativeRef: "",
+      alternativeStrategy: "not_found",
+      reasoning: "AI fallback failed",
+      success: false
+    };
+  }
+}
+
+// src/harness/vision-resolver.ts
+import { z as z3 } from "zod";
+var visionResponseSchema = z3.object({
+  reasoning: z3.string().describe(
+    "\u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u5185\u3067\u8981\u7D20\u3092\u7279\u5B9A\u3057\u305F\u7406\u7531\uFF081-3\u6587\uFF09"
+  ),
+  ref: z3.string().describe(
+    "\u7279\u5B9A\u3057\u305F\u8981\u7D20\u306E ref \u5024\uFF08\u4F8B: e3\uFF09\u3002@\u306F\u542B\u3081\u306A\u3044\u3002\u8A72\u5F53\u3059\u308B\u8981\u7D20\u304C\u898B\u3064\u304B\u3089\u306A\u3044\u5834\u5408\u306F\u7A7A\u6587\u5B57"
+  ),
+  annotationNumber: z3.number().optional().describe(
+    "\u7279\u5B9A\u3057\u305F\u8981\u7D20\u306E\u30A2\u30CE\u30C6\u30FC\u30B7\u30E7\u30F3\u756A\u53F7\uFF08\u30B9\u30AF\u30EA\u30FC\u30F3\u30B7\u30E7\u30C3\u30C8\u4E0A\u306E\u756A\u53F7\u30E9\u30D9\u30EB\uFF09"
+  ),
+  confidence: z3.number().min(0).max(1).describe(
+    "\u7279\u5B9A\u306E\u78BA\u4FE1\u5EA6\uFF080.0-1.0\uFF09"
+  )
+});
+async function resolveWithVision(imageBuffer, annotations, selector, stepDescription, url, failureHistory, debugLogger, aiProvider) {
+  debugLogger?.log({
+    phase: "executor",
+    event: "vision_fallback_start",
+    data: {
+      annotationCount: annotations.length,
+      selector,
+      stepDescription,
+      url,
+      failureHistoryCount: failureHistory.length
+    }
+  });
+  if (annotations.length === 0) {
+    debugLogger?.log({
+      phase: "executor",
+      event: "vision_fallback_skip",
+      data: { reason: "no annotations" }
+    });
+    return null;
+  }
+  const { system, userTextContent } = buildVisionMessages(
+    annotations,
+    selector,
+    stepDescription,
+    url,
+    failureHistory
+  );
+  try {
+    const model = aiProvider ? aiProvider.getModel("vision") : getModel("vision");
+    const { object } = await withAIRetry(
+      () => trackedGenerateObject("vision", {
+        model,
+        messages: [
+          {
+            role: "system",
+            content: system,
+            providerOptions: {
+              anthropic: { cacheControl: { type: "ephemeral" } }
+            }
+          },
+          {
+            role: "user",
+            content: [
+              { type: "text", text: userTextContent },
+              { type: "image", image: imageBuffer }
+            ]
+          }
+        ],
+        schema: visionResponseSchema,
+        temperature: 0
+      }),
+      { label: "vision-resolve" }
+    );
+    debugLogger?.log({
+      phase: "executor",
+      event: "vision_fallback_result",
+      data: {
+        ref: object.ref,
+        reasoning: object.reasoning,
+        annotationNumber: object.annotationNumber,
+        confidence: object.confidence
+      }
+    });
+    if (!object.ref) return null;
+    const matchingAnnotation = annotations.find((a) => a.ref === object.ref);
+    if (!matchingAnnotation) {
+      debugLogger?.log({
+        phase: "executor",
+        event: "vision_fallback_invalid_ref",
+        data: {
+          ref: object.ref,
+          availableRefs: annotations.map((a) => a.ref)
+        }
+      });
+      return null;
+    }
+    return {
+      ref: object.ref,
+      reasoning: object.reasoning,
+      annotationNumber: object.annotationNumber,
+      confidence: object.confidence
+    };
+  } catch (error) {
+    debugLogger?.log({
+      phase: "executor",
+      event: "vision_fallback_error",
+      data: { error: error instanceof Error ? error.message : String(error) }
+    });
+    return null;
+  }
+}
+
+// src/harness/action-validator.ts
+var COMPATIBLE_ROLES = {
+  click: /* @__PURE__ */ new Set([
+    "button",
+    "link",
+    "checkbox",
+    "radio",
+    "tab",
+    "menuitem",
+    "menuitemcheckbox",
+    "menuitemradio",
+    "switch",
+    "option",
+    "treeitem",
+    "row",
+    "cell",
+    "gridcell",
+    "img",
+    "figure"
+  ]),
+  input: /* @__PURE__ */ new Set(["textbox", "searchbox", "combobox", "spinbutton", "textarea"]),
+  select: /* @__PURE__ */ new Set(["combobox", "listbox", "select"]),
+  download: /* @__PURE__ */ new Set(["link", "button", "menuitem", "menuitemcheckbox", "menuitemradio"]),
+  hover: /* @__PURE__ */ new Set(),
+  // 空 = 全ロール OK
+  key: /* @__PURE__ */ new Set()
+  // 空 = セレクタ不要、グローバルキーボード操作
+};
+var CLICK_INCOMPATIBLE_ROLES = /* @__PURE__ */ new Set([
+  "textbox",
+  "searchbox",
+  "textarea",
+  "spinbutton"
+]);
+var VALUE_REQUIRED_ACTIONS = /* @__PURE__ */ new Set(["input", "select"]);
+function isValidRole(role) {
+  return role.length > 1 && /^[a-z]/.test(role);
+}
+function validateAction(snapshot, ref, actionType, value, refs) {
+  const errors = [];
+  const warnings = [];
+  let element = null;
+  const refEntry = refs?.[ref];
+  if (refEntry) {
+    element = { ref, role: refEntry.role, name: refEntry.name ?? "", attributes: {} };
+  } else {
+    element = findElementInSnapshot(snapshot, ref);
+  }
+  if (!element) {
+    errors.push({
+      code: "ref_not_found",
+      message: `[ref=${ref}] \u304C\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5185\u306B\u5B58\u5728\u3057\u307E\u305B\u3093`
+    });
+    return { valid: false, errors, warnings };
+  }
+  const normalizedAction = normalizeActionType(actionType);
+  if (normalizedAction !== "hover" && isValidRole(element.role)) {
+    const compatible = COMPATIBLE_ROLES[normalizedAction];
+    if (compatible && compatible.size > 0) {
+      if (!compatible.has(element.role)) {
+        if (normalizedAction === "click" && !CLICK_INCOMPATIBLE_ROLES.has(element.role)) {
+        } else {
+          errors.push({
+            code: "type_mismatch",
+            message: `\u30A2\u30AF\u30B7\u30E7\u30F3 "${actionType}" \u306F role="${element.role}" \u306E\u8981\u7D20\u3068\u4E92\u63DB\u6027\u304C\u3042\u308A\u307E\u305B\u3093\uFF08ref=${ref}\uFF09`
+          });
+        }
+      }
+    }
+  }
+  if (VALUE_REQUIRED_ACTIONS.has(normalizedAction) && (!value || value.trim() === "")) {
+    errors.push({
+      code: "value_required",
+      message: `\u30A2\u30AF\u30B7\u30E7\u30F3 "${actionType}" \u306B\u306F\u5024\u304C\u5FC5\u8981\u3067\u3059\uFF08ref=${ref}\uFF09`
+    });
+  }
+  if (element.attributes.disabled || element.attributes.disabled === "true") {
+    warnings.push({
+      code: "element_disabled",
+      message: `\u8981\u7D20\u304C disabled \u3067\u3059\uFF08ref=${ref}, role=${element.role}\uFF09`
+    });
+  }
+  if (element.attributes.readonly || element.attributes.readonly === "true") {
+    if (normalizedAction === "input") {
+      warnings.push({
+        code: "element_readonly",
+        message: `\u8981\u7D20\u304C readonly \u3067\u3059\uFF08ref=${ref}, role=${element.role}\uFF09`
+      });
+    }
+  }
+  const overlayWarning = checkOverlay(snapshot, ref);
+  if (overlayWarning) {
+    warnings.push(overlayWarning);
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function normalizeActionType(actionType) {
+  switch (actionType) {
+    case "fill":
+    case "type":
+    case "input":
+      return "input";
+    case "click":
+      return "click";
+    case "select":
+      return "select";
+    case "hover":
+      return "hover";
+    default:
+      return actionType;
+  }
+}
+function checkOverlay(snapshot, targetRef) {
+  const lines = snapshot.split("\n");
+  let dialogLineIndex = -1;
+  let dialogIndent = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trimStart();
+    if (trimmed.startsWith("dialog") || trimmed.startsWith("alertdialog")) {
+      dialogLineIndex = i;
+      dialogIndent = lines[i].length - trimmed.length;
+      break;
+    }
+  }
+  if (dialogLineIndex === -1) return null;
+  const refPattern = `[ref=${targetRef}]`;
+  let targetLineIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(refPattern)) {
+      targetLineIndex = i;
+      break;
+    }
+  }
+  if (targetLineIndex === -1) return null;
+  if (targetLineIndex > dialogLineIndex) {
+    const targetIndent = lines[targetLineIndex].length - lines[targetLineIndex].trimStart().length;
+    if (targetIndent > dialogIndent) {
+      return null;
+    }
+  }
+  return {
+    code: "possible_overlay",
+    message: `dialog/alertdialog \u304C\u5B58\u5728\u3057\u3001\u30BF\u30FC\u30B2\u30C3\u30C8\u8981\u7D20\uFF08ref=${targetRef}\uFF09\u304C\u305D\u306E\u5916\u5074\u306B\u3042\u308A\u307E\u3059\u3002\u30E2\u30FC\u30C0\u30EB\u306B\u906E\u3089\u308C\u3066\u3044\u308B\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059`
+  };
+}
+
+// src/harness/deterministic-resolver.ts
+function resolveDeterministic(snapshot, selector, refs) {
+  const noMatch = {
+    ref: null,
+    matchType: null,
+    confidence: 0
+  };
+  const parsedElements = [];
+  const elements = [];
+  if (refs) {
+    for (const [ref, entry] of Object.entries(refs)) {
+      elements.push({ ref, role: entry.role, name: entry.name ?? "" });
+    }
+  } else {
+    const parsed = parseAllElements(snapshot);
+    parsedElements.push(...parsed);
+    for (const el of parsed) {
+      elements.push({
+        ref: el.ref,
+        role: el.role,
+        name: el.name,
+        placeholder: el.attributes.placeholder
+      });
+    }
+  }
+  if (elements.length === 0) return noMatch;
+  const selectorRole = normalizeString(selector.role);
+  const selectorAriaLabel = normalizeString(selector.ariaLabel);
+  const selectorText = normalizeString(selector.text);
+  const selectorInnerText = normalizeString(selector.innerText);
+  const selectorPlaceholder = normalizeString(selector.placeholder);
+  if (!selectorAriaLabel && !selectorText && !selectorInnerText && !selectorPlaceholder && !selectorRole) return noMatch;
+  const labelLower = selectorAriaLabel?.toLowerCase();
+  const textLower = selectorText?.toLowerCase();
+  const innerTextLower = selectorInnerText?.toLowerCase();
+  let p1 = null;
+  let p2 = null;
+  let p3 = null;
+  let p4 = null;
+  let p5 = null;
+  let p6 = null;
+  let p7 = null;
+  let p8 = null;
+  for (const el of elements) {
+    const nameExact = selectorAriaLabel ? el.name === selectorAriaLabel : false;
+    const roleMatch = selectorRole ? el.role === selectorRole : false;
+    if (roleMatch && nameExact) {
+      if (!p1) {
+        p1 = { ref: el.ref, count: 1 };
+      } else {
+        p1.count++;
+      }
+    }
+    if (nameExact) {
+      if (!p2) {
+        p2 = { ref: el.ref, count: 1 };
+      } else {
+        p2.count++;
+      }
+    }
+    const nameLower = labelLower || textLower || innerTextLower ? el.name.toLowerCase() : "";
+    if (roleMatch && labelLower && nameLower.includes(labelLower)) {
+      if (!p3) {
+        p3 = { ref: el.ref, count: 1 };
+      } else {
+        p3.count++;
+      }
+    }
+    if (roleMatch && textLower && nameLower.includes(textLower)) {
+      if (!p4) {
+        p4 = { ref: el.ref, count: 1 };
+      } else {
+        p4.count++;
+      }
+    }
+    if (!selectorRole && labelLower && nameLower.includes(labelLower)) {
+      if (!p5) {
+        p5 = { ref: el.ref, count: 1 };
+      } else {
+        p5.count++;
+      }
+    }
+    if (roleMatch && innerTextLower && nameLower.includes(innerTextLower)) {
+      if (!p6) {
+        p6 = { ref: el.ref, count: 1 };
+      } else {
+        p6.count++;
+      }
+    }
+    if (selectorPlaceholder && el.placeholder && el.placeholder === selectorPlaceholder) {
+      if (!p7) {
+        p7 = { ref: el.ref, count: 1 };
+      } else {
+        p7.count++;
+      }
+    }
+    if (selectorRole && el.role === selectorRole) {
+      if (!p8) {
+        p8 = { ref: el.ref, count: 1 };
+      } else {
+        p8.count++;
+      }
+    }
+  }
+  if (p1 && p1.count === 1) return { ref: p1.ref, matchType: "exact_role_and_name", confidence: 1 };
+  if (p2 && p2.count === 1) return { ref: p2.ref, matchType: "exact_name", confidence: 0.9 };
+  if (p3 && p3.count === 1) return { ref: p3.ref, matchType: "role_and_partial_name", confidence: 0.7 };
+  if (p4 && p4.count === 1) return { ref: p4.ref, matchType: "role_and_text", confidence: 0.6 };
+  if (p5 && p5.count === 1) return { ref: p5.ref, matchType: "role_and_partial_name", confidence: 0.6 };
+  if (p6 && p6.count === 1) return { ref: p6.ref, matchType: "role_and_innerText", confidence: 0.55 };
+  if (p7 && p7.count === 1) return { ref: p7.ref, matchType: "placeholder", confidence: 0.5 };
+  if (p8 && p8.count === 1) return { ref: p8.ref, matchType: "unique_role", confidence: 0.4 };
+  return noMatch;
+}
+function normalizeString(value) {
+  if (typeof value === "string" && value.trim() !== "") {
+    return value.trim();
+  }
+  return void 0;
+}
+
+// src/harness/confirmation.ts
+function needsConfirmation(step, skipAll) {
+  if (skipAll) return false;
+  return step.requiresConfirmation;
+}
+
+// src/runbook-executor/confirmation.ts
+var CliConfirmationProvider = class {
+  async confirm(step, _stepIndex, _context) {
+    return promptConfirmation(step);
+  }
+};
+async function promptConfirmation(step) {
+  note(
+    `${tf("confirmation.stepInfo", { ordinal: step.ordinal, description: step.description })}
+${tf("confirmation.riskLevelLabel", { level: step.riskLevel, hint: formatRiskHint(step.riskLevel) })}`,
+    t("confirmation.title")
+  );
+  return promptSelect(t("confirmation.selectAction"), [
+    { value: "approve", label: t("confirmation.approve") },
+    { value: "skip", label: t("confirmation.skip") },
+    { value: "abort", label: t("confirmation.abort"), hint: t("confirmation.abortHint") }
+  ]);
+}
+
+// src/context/capture-handler.ts
+import { z as z4 } from "zod";
+var captureValueSchema = z4.object({
+  value: z4.string().nullable().describe("\u62BD\u51FA\u3057\u305F\u5024\u3002\u898B\u3064\u304B\u3089\u306A\u3044\u5834\u5408\u306Fnull")
+});
+async function executeCapture(browser, capture, store) {
+  switch (capture.strategy) {
+    case "snapshot":
+      return captureFromSnapshot(browser, capture);
+    case "url":
+      return captureFromUrl(browser, capture);
+    case "ai":
+      return captureWithAI(browser, capture);
+    case "expression":
+      return captureFromExpression(capture, store);
+    case "evaluate":
+      return captureWithEvaluate(browser, capture);
+    default:
+      log.warn(`Unknown capture strategy: ${capture.strategy}`);
+      return null;
+  }
+}
+async function captureFromSnapshot(browser, capture) {
+  if (!capture.pattern) {
+    log.warn(`Capture "${capture.name}": snapshot strategy requires pattern`);
+    return null;
+  }
+  const snapshot = await browser.snapshot();
+  let re;
+  try {
+    re = new RegExp(capture.pattern);
+  } catch {
+    log.warn(`Capture "${capture.name}": invalid regex pattern: ${capture.pattern}`);
+    return null;
+  }
+  const match = re.exec(snapshot);
+  if (!match) {
+    return null;
+  }
+  const group = capture.group ?? 1;
+  return match[group] ?? match[0] ?? null;
+}
+async function captureFromUrl(browser, capture) {
+  if (!capture.pattern) {
+    log.warn(`Capture "${capture.name}": url strategy requires pattern`);
+    return null;
+  }
+  const currentUrl = await browser.url();
+  let re;
+  try {
+    re = new RegExp(capture.pattern);
+  } catch {
+    log.warn(`Capture "${capture.name}": invalid regex pattern: ${capture.pattern}`);
+    return null;
+  }
+  const match = re.exec(currentUrl);
+  if (!match) {
+    return null;
+  }
+  const group = capture.group ?? 1;
+  return match[group] ?? match[0] ?? null;
+}
+var CAPTURE_SYSTEM_PROMPT = "\u4EE5\u4E0B\u306E\u30DA\u30FC\u30B8\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u304B\u3089\u60C5\u5831\u3092\u62BD\u51FA\u3057\u3066\u304F\u3060\u3055\u3044\u3002\u62BD\u51FA\u5BFE\u8C61\u306E\u8AAC\u660E\u306B\u57FA\u3065\u3044\u3066\u3001\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5185\u304B\u3089\u8A72\u5F53\u3059\u308B\u5024\u3092\u7279\u5B9A\u3057\u3066\u8FD4\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
+async function captureWithAI(browser, capture) {
+  if (!capture.prompt) {
+    log.warn(`Capture "${capture.name}": ai strategy requires prompt`);
+    return null;
+  }
+  const snapshot = filterSnapshot(await browser.snapshot());
+  const currentUrl = await browser.url();
+  const userPrompt = [
+    `## \u62BD\u51FA\u5BFE\u8C61`,
+    capture.prompt,
+    "",
+    `## \u73FE\u5728\u306EURL`,
+    currentUrl,
+    "",
+    `## \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8`,
+    snapshot
+  ].join("\n");
+  try {
+    const { object } = await withAIRetry(
+      () => trackedGenerateObject("extraction", {
+        model: getModel("extraction"),
+        messages: [
+          {
+            role: "system",
+            content: CAPTURE_SYSTEM_PROMPT,
+            providerOptions: {
+              anthropic: { cacheControl: { type: "ephemeral" } }
+            }
+          },
+          { role: "user", content: userPrompt }
+        ],
+        schema: captureValueSchema,
+        temperature: 0
+      }),
+      { label: "capture-ai" }
+    );
+    return object.value ?? null;
+  } catch (error) {
+    log.warn(
+      `Capture "${capture.name}" AI extraction failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+async function captureWithEvaluate(browser, capture) {
+  if (!capture.expression) {
+    log.warn(`Capture "${capture.name}": evaluate strategy requires expression (JavaScript code)`);
+    return null;
+  }
+  try {
+    const result = await browser.evaluate(capture.expression);
+    if (result === null || result === void 0) {
+      return null;
+    }
+    return typeof result === "string" ? result : JSON.stringify(result);
+  } catch (error) {
+    log.warn(
+      `Capture "${capture.name}" evaluate failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+function captureFromExpression(capture, store) {
+  if (!capture.expression) {
+    log.warn(`Capture "${capture.name}": expression strategy requires expression`);
+    return null;
+  }
+  const result = store.resolveTemplate(capture.expression);
+  if (/\{\{\w+\}\}/.test(result)) {
+    return null;
+  }
+  return result;
+}
+
+// src/context/expression-evaluator.ts
+var COMPARISON_OPERATORS = ["===", "!==", "==", "!=", "<=", ">=", "<", ">"];
+function evaluateCondition(expression) {
+  const trimmed = expression.trim();
+  if (!trimmed) {
+    return { value: false, error: "Empty expression" };
+  }
+  if (trimmed.startsWith("!") && !trimmed.startsWith("!=")) {
+    const inner = trimmed.slice(1).trim();
+    const operand2 = parseOperand(inner);
+    if (operand2 === void 0) {
+      return { value: false, error: `Cannot parse operand: ${inner}` };
+    }
+    return { value: !isTruthy(operand2) };
+  }
+  const comparison = findComparison(trimmed);
+  if (comparison) {
+    const { left, operator, right } = comparison;
+    const leftVal = parseOperand(left);
+    const rightVal = parseOperand(right);
+    if (leftVal === void 0) {
+      return { value: false, error: `Cannot parse left operand: ${left}` };
+    }
+    if (rightVal === void 0) {
+      return { value: false, error: `Cannot parse right operand: ${right}` };
+    }
+    return { value: compare(leftVal, rightVal, operator) };
+  }
+  const operand = parseOperand(trimmed);
+  if (operand === void 0) {
+    return { value: false, error: `Cannot parse expression: ${trimmed}` };
+  }
+  return { value: isTruthy(operand) };
+}
+function findComparison(expr) {
+  for (const op of COMPARISON_OPERATORS) {
+    const idx = findOperatorOutsideStrings(expr, op);
+    if (idx !== -1) {
+      return {
+        left: expr.slice(0, idx).trim(),
+        operator: op,
+        right: expr.slice(idx + op.length).trim()
+      };
+    }
+  }
+  return null;
+}
+function findOperatorOutsideStrings(expr, op) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < expr.length; i++) {
+    const ch = expr[i];
+    if (ch === "'" && !inDouble && (i === 0 || expr[i - 1] !== "\\")) {
+      inSingle = !inSingle;
+    } else if (ch === '"' && !inSingle && (i === 0 || expr[i - 1] !== "\\")) {
+      inDouble = !inDouble;
+    } else if (!inSingle && !inDouble) {
+      if (expr.slice(i, i + op.length) === op) {
+        if (op === "<" && expr[i + 1] === "=") continue;
+        if (op === ">" && expr[i + 1] === "=") continue;
+        if (op === "=" && op.length === 1) continue;
+        if (op === "==" && expr[i + 2] === "=") continue;
+        if (op === "!=" && expr[i + 2] === "=") continue;
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function parseOperand(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+    return trimmed.slice(1, -1).replace(/\\'/g, "'").replace(/\\"/g, '"');
+  }
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+    return Number(trimmed);
+  }
+  return trimmed;
+}
+function isTruthy(val) {
+  if (typeof val === "boolean") return val;
+  if (typeof val === "number") return val !== 0;
+  if (typeof val === "string") return val !== "" && val !== "false" && val !== "0";
+  return false;
+}
+function compare(left, right, op) {
+  switch (op) {
+    case "===":
+      return left === right;
+    case "!==":
+      return left !== right;
+    case "==":
+      return String(left) === String(right);
+    case "!=":
+      return String(left) !== String(right);
+    case "<":
+      return toNumber(left) < toNumber(right);
+    case ">":
+      return toNumber(left) > toNumber(right);
+    case "<=":
+      return toNumber(left) <= toNumber(right);
+    case ">=":
+      return toNumber(left) >= toNumber(right);
+    default:
+      return false;
+  }
+}
+function toNumber(val) {
+  if (typeof val === "number") return val;
+  if (typeof val === "boolean") return val ? 1 : 0;
+  const n = Number(val);
+  return Number.isNaN(n) ? 0 : n;
+}
+
+// src/context/snapshot-cache.ts
+import { createHash as createHash4 } from "crypto";
+var SnapshotCache = class {
+  constructor(maxEntries = 5) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxEntries = maxEntries;
+  }
+  /**
+   * フィルタ済みスナップショットを返す（キャッシュがあればそれを利用）。
+   *
+   * opts が異なる場合は別キーとして扱う（filledSelectors のサイズをキーに含める）。
+   */
+  getFiltered(raw, opts) {
+    const key = this.buildKey(raw, opts);
+    const existing = this.cache.get(key);
+    if (existing) {
+      this.cache.delete(key);
+      this.cache.set(key, existing);
+      return existing.filtered;
+    }
+    const filtered = filterSnapshot(raw, opts);
+    const tokenEstimate = Math.ceil(filtered.length / 4);
+    this.evictIfNeeded();
+    this.cache.set(key, {
+      rawHash: this.hashSnapshot(raw),
+      filtered,
+      tokenEstimate,
+      createdAt: Date.now()
+    });
+    return filtered;
+  }
+  /**
+   * 2つのスナップショットが同一内容かどうかをハッシュで高速判定する。
+   */
+  hasChanged(rawA, rawB) {
+    return this.hashSnapshot(rawA) !== this.hashSnapshot(rawB);
+  }
+  /** キャッシュをクリアする */
+  clear() {
+    this.cache.clear();
+  }
+  /** 現在のキャッシュエントリ数 */
+  get size() {
+    return this.cache.size;
+  }
+  buildKey(raw, opts) {
+    const rawHash = this.hashSnapshot(raw);
+    const filledCount = opts?.filledSelectors?.size ?? 0;
+    return `${rawHash}:${filledCount}`;
+  }
+  hashSnapshot(raw) {
+    return createHash4("sha256").update(raw).digest("hex").slice(0, 16);
+  }
+  evictIfNeeded() {
+    while (this.cache.size >= this.maxEntries) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.cache.delete(oldestKey);
+      }
+    }
+  }
+};
+
+// src/context/context-chunker.ts
+var ContextChunker = class {
+  constructor(markdown) {
+    /** 直近の selectRelevant() で選択されたチャンク数 */
+    this._lastSelectedCount = 0;
+    this.fullText = markdown;
+    this.chunks = parseMarkdownIntoChunks(markdown);
+  }
+  /**
+   * ステップ説明 + URL に関連するチャンクを選択して返す。
+   * キーワードオーバーラップスコアリングによる選択（AI 不要）。
+   *
+   * @param stepDescription ステップの説明テキスト
+   * @param url 現在のページURL
+   * @param maxTokens 最大トークン数（デフォルト: 2000）
+   * @returns 関連チャンクを結合したテキスト。関連チャンクがなければ空文字。
+   */
+  selectRelevant(stepDescription, url, maxTokens = 2e3) {
+    if (this.chunks.length === 0) {
+      this._lastSelectedCount = 0;
+      return this.fullText;
+    }
+    const queryTerms = extractKeywords(`${stepDescription} ${url}`);
+    if (queryTerms.length === 0) {
+      this._lastSelectedCount = 0;
+      return this.fullText;
+    }
+    const scored = this.chunks.map((chunk) => ({
+      chunk,
+      score: keywordOverlapScore(queryTerms, chunk.keywords)
+    })).filter((s) => s.score > 0).sort((a, b) => b.score - a.score);
+    if (scored.length === 0) {
+      this._lastSelectedCount = 0;
+      const fullTokens = Math.ceil(this.fullText.length / 4);
+      if (fullTokens <= maxTokens) return this.fullText;
+      return this.fullText.slice(0, maxTokens * 4) + "\n[... truncated]";
+    }
+    let tokens = 0;
+    const selected = [];
+    for (const { chunk } of scored) {
+      if (tokens + chunk.tokenEstimate > maxTokens) {
+        continue;
+      }
+      selected.push(chunk);
+      tokens += chunk.tokenEstimate;
+    }
+    if (selected.length === 0 && scored.length > 0) {
+      this._lastSelectedCount = 1;
+      const best = scored[0].chunk;
+      const maxChars = maxTokens * 4;
+      return `### ${best.heading}
+${best.content.slice(0, maxChars)}
+[... truncated]`;
+    }
+    this._lastSelectedCount = selected.length;
+    return selected.map((c) => `### ${c.heading}
+${c.content}`).join("\n\n");
+  }
+  /** 全文を返す（フォールバック用） */
+  getFull() {
+    return this.fullText;
+  }
+  /** チャンク数を返す（テスト・デバッグ用） */
+  get chunkCount() {
+    return this.chunks.length;
+  }
+  /** 直近の selectRelevant() で選択されたチャンク数 */
+  get lastSelectedCount() {
+    return this._lastSelectedCount;
+  }
+};
+function parseMarkdownIntoChunks(markdown) {
+  const lines = markdown.split("\n");
+  const chunks = [];
+  let currentHeading = "";
+  let currentContent = [];
+  for (const line of lines) {
+    const headingMatch = line.match(/^#{1,3}\s+(.+)/);
+    if (headingMatch) {
+      if (currentContent.length > 0 || currentHeading) {
+        const content2 = currentContent.join("\n").trim();
+        if (content2) {
+          chunks.push(buildChunk(currentHeading || "untitled", content2));
+        }
+      }
+      currentHeading = headingMatch[1].trim();
+      currentContent = [];
+    } else {
+      currentContent.push(line);
+    }
+  }
+  const content = currentContent.join("\n").trim();
+  if (content) {
+    chunks.push(buildChunk(currentHeading || "untitled", content));
+  }
+  return chunks;
+}
+function buildChunk(heading, content) {
+  const fullText = `${heading} ${content}`;
+  return {
+    heading,
+    content,
+    tokenEstimate: Math.ceil(fullText.length / 4),
+    keywords: extractKeywords(fullText)
+  };
+}
+function extractKeywords(text) {
+  const normalized = text.toLowerCase();
+  const words = /* @__PURE__ */ new Set();
+  const urlPaths = normalized.match(/\/[a-z0-9_-]+/g);
+  if (urlPaths) {
+    for (const path of urlPaths) {
+      words.add(path.replace("/", ""));
+    }
+  }
+  const englishWords = normalized.match(/[a-z][a-z0-9_-]{2,}/g);
+  if (englishWords) {
+    for (const w of englishWords) {
+      if (!STOP_WORDS.has(w)) {
+        words.add(w);
+      }
+    }
+  }
+  const japaneseWords = text.match(/[\u30A0-\u30FF]{2,}|[\u4E00-\u9FFF]{2,}/g);
+  if (japaneseWords) {
+    for (const w of japaneseWords) {
+      words.add(w);
+    }
+  }
+  return [...words];
+}
+function keywordOverlapScore(queryTerms, chunkKeywords) {
+  if (queryTerms.length === 0 || chunkKeywords.length === 0) return 0;
+  let matchCount = 0;
+  for (const qt of queryTerms) {
+    for (const ck of chunkKeywords) {
+      if (ck.includes(qt) || qt.includes(ck)) {
+        matchCount++;
+        break;
+      }
+    }
+  }
+  return matchCount / queryTerms.length;
+}
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "but",
+  "not",
+  "you",
+  "all",
+  "can",
+  "has",
+  "her",
+  "was",
+  "one",
+  "our",
+  "out",
+  "day",
+  "had",
+  "hot",
+  "may",
+  "who",
+  "did",
+  "get",
+  "let",
+  "say",
+  "she",
+  "too",
+  "use",
+  "that",
+  "this",
+  "with",
+  "have",
+  "from",
+  "they",
+  "been",
+  "will",
+  "each",
+  "make",
+  "like",
+  "when",
+  "than",
+  "them",
+  "into",
+  "some",
+  "could",
+  "other",
+  "about",
+  "which",
+  "their",
+  "there",
+  "would",
+  "click",
+  "input",
+  "select",
+  "button",
+  "page",
+  "form",
+  "step"
+]);
+
+// src/runbook-executor/executor.ts
+async function applySkillTransform(browser, rawSnapshot, url, skills, stepContext) {
+  if (!skills || skills.length === 0) return null;
+  const locale = getLocale();
+  for (const skill of skills) {
+    const shouldActivate = stepContext && skill.shouldActivateForStep ? skill.shouldActivateForStep(url, stepContext) : skill.shouldActivate(url);
+    if (shouldActivate) {
+      try {
+        return await skill.transformSnapshot(browser, rawSnapshot, { url, locale });
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function mergeNotesIntoContext(contextMarkdown, notes) {
+  if (!notes) return contextMarkdown;
+  const section = `## Generation Notes (Human Guidance)
+${notes}`;
+  return `${contextMarkdown}
+
+${section}`;
+}
+function resolveContextMarkdown(config, runbook) {
+  return mergeNotesIntoContext(config.contextMarkdown, runbook.notes);
+}
+async function execute(config, runbook, opts) {
+  const totalStart = performance.now();
+  const ownsBrowser = !opts.browser;
+  const browser = opts.browser ?? new AgentBrowser();
+  const results = [];
+  let aborted = false;
+  let recordedVideoPaths;
+  const logger = opts.logger ?? new NoopLogger();
+  const createSpinner = opts.createSpinner ?? (() => new NoopSpinner());
+  const debugLogger = createDebugLogger({
+    filePath: config.debugLogPath,
+    console: config.debugConsole
+  });
+  const snapshotCache = new SnapshotCache();
+  config.contextMarkdown = resolveContextMarkdown(config, runbook);
+  const contextChunker = new ContextChunker(config.contextMarkdown);
+  const failureRegistry = new FailureRegistry();
+  const pauseMs = config.stepDelay ?? runbook.settings.pauseBetweenSteps;
+  if (config.screenshotDir) {
+    await mkdir2(config.screenshotDir, { recursive: true });
+  }
+  try {
+    if (ownsBrowser) {
+      const startUrl = opts.store.resolveTemplate(runbook.metadata.startUrl);
+      const openSpinner = createSpinner();
+      openSpinner.start(tf("executor.openingUrl", { url: startUrl }));
+      await browser.open(startUrl, {
+        headless: config.headless,
+        stealth: config.stealth,
+        proxy: config.proxy
+      });
+      await browser.waitForDOMStability(3e3);
+      openSpinner.stop(t("executor.browserReady"));
+      if (config.videoDir) {
+        try {
+          await browser.startRecording(config.videoDir);
+          logger.info(tf("executor.recordingStarted", { path: config.videoDir }));
+        } catch (e) {
+          logger.warn(tf("executor.recordingStartFailed", { error: e instanceof Error ? e.message : String(e) }));
+        }
+      }
+    }
+    for (const step of runbook.steps) {
+      if (aborted) break;
+      if (opts.abortSignal?.aborted) {
+        aborted = true;
+        logger.warn(t("executor.jobAbortedTimeout"));
+        break;
+      }
+      logger.step(`Step ${step.ordinal}/${runbook.steps.length}: ${step.description}`);
+      await opts.onStepStart?.(step.ordinal, step.description, step.action.type).catch(() => {
+      });
+      const start = Date.now();
+      if (step.condition) {
+        const resolved = opts.store.resolveTemplate(step.condition);
+        const evalResult = evaluateCondition(resolved);
+        debugLogger.log({
+          phase: "executor",
+          event: "condition_eval",
+          step: step.ordinal,
+          data: { condition: step.condition, resolved, result: evalResult.value, error: evalResult.error }
+        });
+        if (!evalResult.value) {
+          logger.warn(tf("executor.conditionSkipping", { condition: step.condition }));
+          const skipDuration = Date.now() - start;
+          results.push({
+            ordinal: step.ordinal,
+            description: step.description,
+            actionType: step.action.type,
+            status: "skipped",
+            durationMs: skipDuration,
+            conditionSkipped: true
+          });
+          await opts.onStepComplete?.(step.ordinal, "skipped", skipDuration, step.description, step.action.type).catch(() => {
+          });
+          continue;
+        }
+      }
+      if (step.branches) {
+        const branchResult = await executeBranchStep(
+          browser,
+          step,
+          runbook,
+          config,
+          opts,
+          debugLogger,
+          pauseMs,
+          logger,
+          snapshotCache,
+          contextChunker,
+          failureRegistry
+        );
+        results.push(branchResult);
+        if (branchResult.status === "failed" && runbook.settings.stopOnError) {
+          logger.error(t("executor.stopOnErrorAborting"));
+          aborted = true;
+        }
+        continue;
+      }
+      if (step.loop && step.steps) {
+        const loopResult = await executeLoopStep(
+          browser,
+          step,
+          runbook,
+          config,
+          opts,
+          debugLogger,
+          pauseMs,
+          logger,
+          snapshotCache,
+          contextChunker,
+          failureRegistry
+        );
+        results.push(loopResult);
+        if (loopResult.status === "failed" && runbook.settings.stopOnError) {
+          logger.error(t("executor.stopOnErrorAborting"));
+          aborted = true;
+        }
+        continue;
+      }
+      if (needsConfirmation(step, config.skipConfirmation) && opts.confirmationProvider) {
+        logger.info(tf("executor.approvalWaiting", { ordinal: step.ordinal, riskLevel: step.riskLevel }));
+        debugLogger.log({
+          phase: "executor",
+          event: "approval_pending",
+          step: step.ordinal,
+          data: { riskLevel: step.riskLevel, description: step.description }
+        });
+        const result = await opts.confirmationProvider.confirm(step, step.ordinal, {
+          goal: runbook.metadata.goal
+        });
+        debugLogger.log({
+          phase: "executor",
+          event: "approval_received",
+          step: step.ordinal,
+          data: { result }
+        });
+        if (result === "abort") {
+          logger.error(tf("executor.approvalAborted", { ordinal: step.ordinal }));
+          aborted = true;
+          results.push({
+            ordinal: step.ordinal,
+            description: step.description,
+            actionType: step.action.type,
+            status: "skipped",
+            durationMs: Date.now() - start,
+            error: t("executor.userAborted")
+          });
+          await opts.onStepComplete?.(step.ordinal, "skipped", Date.now() - start, step.description, step.action.type).catch(() => {
+          });
+          break;
+        }
+        if (result === "skip") {
+          logger.warn(tf("executor.approvalSkipped", { ordinal: step.ordinal }));
+          results.push({
+            ordinal: step.ordinal,
+            description: step.description,
+            actionType: step.action.type,
+            status: "skipped",
+            durationMs: Date.now() - start
+          });
+          await opts.onStepComplete?.(step.ordinal, "skipped", Date.now() - start, step.description, step.action.type).catch(() => {
+          });
+          continue;
+        }
+        logger.success(tf("executor.approvalApproved", { ordinal: step.ordinal }));
+      }
+      try {
+        const stepResult = await executeStep(
+          browser,
+          step,
+          runbook,
+          config,
+          opts,
+          debugLogger,
+          logger,
+          snapshotCache,
+          contextChunker,
+          failureRegistry
+        );
+        results.push({ ...stepResult, ordinal: step.ordinal, description: step.description, actionType: step.action.type });
+        opts.store.updateWorkingMemory(
+          step.ordinal,
+          runbook.steps.length,
+          stepResult.status === "success",
+          step.url,
+          step.action.type,
+          step.description
+        );
+        if (stepResult.extractedData) {
+          opts.store.set("extractedData", stepResult.extractedData);
+        }
+        if (stepResult.status === "failed" && runbook.settings.stopOnError) {
+          logger.error(t("executor.stopOnErrorAborting"));
+          aborted = true;
+          break;
+        }
+        if (step.captures && step.captures.length > 0) {
+          await executeCapturePhase(browser, step, opts.store, results, runbook, debugLogger, logger);
+          if (results[results.length - 1].status === "failed" && runbook.settings.stopOnError) {
+            aborted = true;
+          }
+        }
+        if (step.memoryOperations && opts.dataStore) {
+          await executeMemoryOperations(step, opts.store, opts.dataStore, debugLogger, logger);
+        }
+        if (config.screenshotDir) {
+          const filename = `step-${String(step.ordinal).padStart(3, "0")}.png`;
+          try {
+            await browser.screenshot(join3(config.screenshotDir, filename));
+          } catch {
+          }
+        }
+        const lastResult = results[results.length - 1];
+        await opts.onStepComplete?.(step.ordinal, lastResult.status, lastResult.durationMs, step.description, step.action.type).catch(() => {
+        });
+        if (pauseMs > 0) {
+          await new Promise((r) => setTimeout(r, pauseMs));
+        }
+      } catch (error) {
+        const rawErrorMsg = error instanceof Error ? error.message : String(error);
+        const errorMsg = sanitizeBrowserError(rawErrorMsg);
+        logger.error(errorMsg);
+        debugLogger.log({
+          phase: "executor",
+          event: "step_error",
+          step: step.ordinal,
+          data: { error: rawErrorMsg }
+        });
+        results.push({
+          ordinal: step.ordinal,
+          description: step.description,
+          actionType: step.action.type,
+          status: "failed",
+          durationMs: Date.now() - start,
+          error: errorMsg
+        });
+        await opts.onStepFailed?.(step.ordinal, errorMsg).catch(() => {
+        });
+        if (runbook.settings.stopOnError) {
+          aborted = true;
+          break;
+        }
+      }
+    }
+  } finally {
+    if (ownsBrowser && browser.isRecording()) {
+      try {
+        const result = await browser.stopRecording();
+        if (result.paths.length > 0) {
+          recordedVideoPaths = result.paths;
+          for (const p of result.paths) {
+            logger.info(tf("executor.recordingComplete", { path: p }));
+          }
+        }
+      } catch (e) {
+        logger.warn(tf("executor.recordingStopFailed", { error: e instanceof Error ? e.message : String(e) }));
+      }
+    }
+    if (ownsBrowser) {
+      try {
+        await browser.close();
+      } catch {
+      }
+    }
+  }
+  const metricsSummary = getActiveMetricsCollector().getSummary();
+  if (metricsSummary.totalCalls > 0) {
+    debugLogger.log({
+      phase: "executor",
+      event: "ai_metrics_summary",
+      data: metricsSummary
+    });
+  }
+  await debugLogger.flush();
+  const succeeded = results.filter((r) => r.status === "success").length;
+  const failed = results.filter((r) => r.status === "failed").length;
+  const skipped = results.filter((r) => r.status === "skipped").length;
+  const memoryCollections = opts.dataStore ? Object.fromEntries(
+    opts.dataStore.listCollections().map((c) => [c, opts.dataStore.count(c)])
+  ) : void 0;
+  const downloadedFiles = opts.downloadManager ? opts.downloadManager.getAllPaths() : void 0;
+  return {
+    runbookTitle: runbook.title,
+    startUrl: runbook.metadata.startUrl,
+    totalSteps: runbook.steps.length,
+    executed: succeeded + failed,
+    succeeded,
+    failed,
+    skipped,
+    aborted,
+    steps: results,
+    totalDurationMs: Math.round(performance.now() - totalStart),
+    ...memoryCollections && Object.keys(memoryCollections).length > 0 ? { memoryCollections } : {},
+    ...downloadedFiles && downloadedFiles.length > 0 ? { downloadedFiles } : {},
+    ...recordedVideoPaths && recordedVideoPaths.length > 0 ? { videoPaths: recordedVideoPaths } : {}
+  };
+}
+async function executeCapturePhase(browser, step, store, results, runbook, debugLogger, logger) {
+  if (!step.captures || step.captures.length === 0) return;
+  const capturedValues = {};
+  for (const capture of step.captures) {
+    const value = await executeCapture(browser, capture, store);
+    if (value !== null) {
+      store.set(capture.name, value);
+      const maskedValue = store.isSensitive(capture.name) ? "****" : value;
+      capturedValues[capture.name] = maskedValue;
+      logger.success(`Captured: ${capture.name} = "${maskedValue}"`);
+      debugLogger.log({
+        phase: "executor",
+        event: "capture",
+        step: step.ordinal,
+        data: { name: capture.name, strategy: capture.strategy, value: maskedValue }
+      });
+    } else if (capture.required) {
+      logger.error(`Required capture "${capture.name}" failed`);
+      results[results.length - 1].status = "failed";
+      results[results.length - 1].error = `Required capture "${capture.name}" failed`;
+    } else {
+      logger.warn(`Optional capture "${capture.name}" returned no value`);
+    }
+  }
+  if (Object.keys(capturedValues).length > 0) {
+    results[results.length - 1].capturedValues = capturedValues;
+  }
+}
+async function executeLoopStep(browser, step, runbook, config, opts, debugLogger, pauseMs, logger, snapshotCache, contextChunker, failureRegistry) {
+  const loop = step.loop;
+  if (loop.forEach) {
+    return executeForEachLoop(
+      browser,
+      step,
+      runbook,
+      config,
+      opts,
+      debugLogger,
+      pauseMs,
+      logger,
+      snapshotCache,
+      contextChunker,
+      failureRegistry
+    );
+  }
+  const start = Date.now();
+  const store = opts.store;
+  const subSteps = step.steps;
+  const maxIter = loop.maxIterations ?? 10;
+  const counterVar = loop.counterVariable ?? "__loopIndex";
+  const allIterResults = [];
+  let iterations = 0;
+  let loopFailed = false;
+  debugLogger.log({
+    phase: "executor",
+    event: "loop_start",
+    step: step.ordinal,
+    data: { condition: loop.condition, maxIterations: maxIter, counterVariable: counterVar }
+  });
+  for (let i = 0; i < maxIter; i++) {
+    if (opts.abortSignal?.aborted) {
+      loopFailed = true;
+      break;
+    }
+    const resolved = store.resolveTemplate(loop.condition);
+    const evalResult = evaluateCondition(resolved);
+    debugLogger.log({
+      phase: "executor",
+      event: "loop_condition",
+      step: step.ordinal,
+      data: { iteration: i, condition: loop.condition, resolved, result: evalResult.value }
+    });
+    if (!evalResult.value) {
+      logger.info(`Loop condition false at iteration ${i}, exiting loop`);
+      break;
+    }
+    store.set(counterVar, String(i));
+    iterations++;
+    logger.step(`Loop ${step.ordinal} iteration ${i}/${maxIter}`);
+    const { results: iterResults, failed } = await executeSubSteps(
+      browser,
+      subSteps,
+      runbook,
+      config,
+      opts,
+      debugLogger,
+      pauseMs,
+      logger,
+      snapshotCache,
+      contextChunker,
+      failureRegistry
+    );
+    allIterResults.push(iterResults);
+    if (failed) {
+      loopFailed = true;
+      break;
+    }
+  }
+  debugLogger.log({
+    phase: "executor",
+    event: "loop_end",
+    step: step.ordinal,
+    data: { iterations, failed: loopFailed }
+  });
+  return {
+    ordinal: step.ordinal,
+    description: step.description,
+    actionType: "loop",
+    status: loopFailed ? "failed" : "success",
+    durationMs: Date.now() - start,
+    loopIterations: iterations,
+    subStepResults: allIterResults
+  };
+}
+async function executeForEachLoop(browser, step, runbook, config, opts, debugLogger, pauseMs, logger, snapshotCache, contextChunker, failureRegistry) {
+  const start = Date.now();
+  const store = opts.store;
+  const loop = step.loop;
+  const subSteps = step.steps;
+  const maxIter = loop.maxIterations ?? 100;
+  const itemVar = loop.itemVariable ?? "__item";
+  const indexVar = loop.indexVariable ?? "__index";
+  const rawForEach = store.resolveTemplate(loop.forEach);
+  let items;
+  if (rawForEach.startsWith("collection:")) {
+    const collectionName = rawForEach.slice("collection:".length);
+    if (!opts.dataStore) {
+      return {
+        ordinal: step.ordinal,
+        description: step.description,
+        actionType: "forEach",
+        status: "failed",
+        durationMs: Date.now() - start,
+        error: `forEach collection: requires dataStore (collection: ${collectionName})`
+      };
+    }
+    items = opts.dataStore.getAll(collectionName);
+  } else {
+    try {
+      const parsed = JSON.parse(rawForEach);
+      if (!Array.isArray(parsed)) {
+        return {
+          ordinal: step.ordinal,
+          description: step.description,
+          actionType: "forEach",
+          status: "failed",
+          durationMs: Date.now() - start,
+          error: `forEach value must be a JSON array, got ${typeof parsed}`
+        };
+      }
+      items = parsed;
+    } catch {
+      return {
+        ordinal: step.ordinal,
+        description: step.description,
+        actionType: "forEach",
+        status: "failed",
+        durationMs: Date.now() - start,
+        error: `forEach value is not valid JSON: ${rawForEach.slice(0, 100)}`
+      };
+    }
+  }
+  const effectiveItems = items.slice(0, maxIter);
+  debugLogger.log({
+    phase: "executor",
+    event: "forEach_start",
+    step: step.ordinal,
+    data: {
+      forEach: loop.forEach,
+      itemCount: items.length,
+      effectiveCount: effectiveItems.length,
+      maxIterations: maxIter,
+      itemVariable: itemVar,
+      indexVariable: indexVar
+    }
+  });
+  const allIterResults = [];
+  let loopFailed = false;
+  for (let i = 0; i < effectiveItems.length; i++) {
+    if (opts.abortSignal?.aborted) {
+      loopFailed = true;
+      break;
+    }
+    store.setForEachItem(itemVar, effectiveItems[i], indexVar, i);
+    logger.step(`forEach ${step.ordinal} [${i + 1}/${effectiveItems.length}]`);
+    const { results: iterResults, failed } = await executeSubSteps(
+      browser,
+      subSteps,
+      runbook,
+      config,
+      opts,
+      debugLogger,
+      pauseMs,
+      logger,
+      snapshotCache,
+      contextChunker,
+      failureRegistry
+    );
+    allIterResults.push(iterResults);
+    if (failed) {
+      loopFailed = true;
+      break;
+    }
+  }
+  store.clearForEachItem(itemVar, indexVar);
+  debugLogger.log({
+    phase: "executor",
+    event: "forEach_end",
+    step: step.ordinal,
+    data: { iterations: allIterResults.length, failed: loopFailed }
+  });
+  return {
+    ordinal: step.ordinal,
+    description: step.description,
+    actionType: "forEach",
+    status: loopFailed ? "failed" : "success",
+    durationMs: Date.now() - start,
+    loopIterations: allIterResults.length,
+    forEachItemCount: items.length,
+    subStepResults: allIterResults
+  };
+}
+async function executeSubSteps(browser, subSteps, runbook, config, opts, debugLogger, pauseMs, logger, snapshotCache, contextChunker, failureRegistry) {
+  const store = opts.store;
+  const results = [];
+  let failed = false;
+  for (const subStep of subSteps) {
+    if (subStep.condition) {
+      const subResolved = store.resolveTemplate(subStep.condition);
+      const subEval = evaluateCondition(subResolved);
+      if (!subEval.value) {
+        logger.warn(`  Sub-step ${subStep.ordinal} condition false, skipping`);
+        results.push({
+          ordinal: subStep.ordinal,
+          description: subStep.description,
+          actionType: subStep.action.type,
+          status: "skipped",
+          durationMs: 0,
+          conditionSkipped: true
+        });
+        continue;
+      }
+    }
+    if (subStep.branches) {
+      const branchResult = await executeBranchStep(
+        browser,
+        subStep,
+        runbook,
+        config,
+        opts,
+        debugLogger,
+        pauseMs,
+        logger,
+        snapshotCache,
+        contextChunker,
+        failureRegistry
+      );
+      results.push(branchResult);
+      if (branchResult.status === "failed" && runbook.settings.stopOnError) {
+        failed = true;
+        break;
+      }
+      continue;
+    }
+    if (subStep.loop && subStep.steps) {
+      const loopResult = await executeLoopStep(
+        browser,
+        subStep,
+        runbook,
+        config,
+        opts,
+        debugLogger,
+        pauseMs,
+        logger,
+        snapshotCache,
+        contextChunker,
+        failureRegistry
+      );
+      results.push(loopResult);
+      if (loopResult.status === "failed" && runbook.settings.stopOnError) {
+        failed = true;
+        break;
+      }
+      continue;
+    }
+    await opts.onStepStart?.(subStep.ordinal, subStep.description, subStep.action.type).catch(() => {
+    });
+    try {
+      const subResult = await executeStep(
+        browser,
+        subStep,
+        runbook,
+        config,
+        opts,
+        debugLogger,
+        logger,
+        snapshotCache,
+        contextChunker,
+        failureRegistry
+      );
+      results.push({
+        ...subResult,
+        ordinal: subStep.ordinal,
+        description: subStep.description,
+        actionType: subStep.action.type
+      });
+      store.updateWorkingMemory(
+        subStep.ordinal,
+        runbook.steps.length,
+        subResult.status === "success",
+        subStep.url,
+        subStep.action.type,
+        subStep.description
+      );
+      if (subResult.extractedData) {
+        store.set("extractedData", subResult.extractedData);
+      }
+      if (subResult.status === "failed" && runbook.settings.stopOnError) {
+        failed = true;
+        break;
+      }
+      if (subStep.captures && subStep.captures.length > 0) {
+        await executeCapturePhase(
+          browser,
+          subStep,
+          store,
+          results,
+          runbook,
+          debugLogger,
+          logger
+        );
+        if (results[results.length - 1].status === "failed" && runbook.settings.stopOnError) {
+          failed = true;
+          break;
+        }
+      }
+      if (subStep.memoryOperations && opts.dataStore) {
+        await executeMemoryOperations(subStep, store, opts.dataStore, debugLogger, logger);
+      }
+      const lastSubResult = results[results.length - 1];
+      await opts.onStepComplete?.(subStep.ordinal, lastSubResult.status, lastSubResult.durationMs, subStep.description, subStep.action.type).catch(() => {
+      });
+      if (pauseMs > 0) {
+        await new Promise((r) => setTimeout(r, pauseMs));
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      logger.error(errorMsg);
+      results.push({
+        ordinal: subStep.ordinal,
+        description: subStep.description,
+        actionType: subStep.action.type,
+        status: "failed",
+        durationMs: 0,
+        error: errorMsg
+      });
+      await opts.onStepFailed?.(subStep.ordinal, errorMsg).catch(() => {
+      });
+      if (runbook.settings.stopOnError) {
+        failed = true;
+        break;
+      }
+    }
+  }
+  return { results, failed };
+}
+async function executeBranchStep(browser, step, runbook, config, opts, debugLogger, pauseMs, logger, snapshotCache, contextChunker, failureRegistry) {
+  const start = Date.now();
+  const store = opts.store;
+  const branches = step.branches;
+  const resolvedValue = store.resolveTemplate(branches.value);
+  debugLogger.log({
+    phase: "executor",
+    event: "branch_start",
+    step: step.ordinal,
+    data: { value: branches.value, resolved: resolvedValue, caseCount: branches.cases.length }
+  });
+  let matchedSteps = null;
+  let matchLabel = "";
+  for (const branchCase of branches.cases) {
+    const resolvedMatch = store.resolveTemplate(branchCase.match);
+    if (resolvedValue === resolvedMatch) {
+      matchedSteps = branchCase.steps;
+      matchLabel = branchCase.match;
+      break;
+    }
+  }
+  if (!matchedSteps && branches.default) {
+    matchedSteps = branches.default.steps;
+    matchLabel = "default";
+  }
+  if (!matchedSteps) {
+    logger.warn(`Branch: no matching case for "${resolvedValue}", skipping`);
+    debugLogger.log({
+      phase: "executor",
+      event: "branch_no_match",
+      step: step.ordinal,
+      data: { value: resolvedValue }
+    });
+    return {
+      ordinal: step.ordinal,
+      description: step.description,
+      actionType: "branch",
+      status: "skipped",
+      durationMs: Date.now() - start,
+      branchMatch: void 0
+    };
+  }
+  logger.step(`Branch: matched "${matchLabel}" (value="${resolvedValue}")`);
+  debugLogger.log({
+    phase: "executor",
+    event: "branch_matched",
+    step: step.ordinal,
+    data: { value: resolvedValue, match: matchLabel, subStepCount: matchedSteps.length }
+  });
+  const { results: subResults, failed } = await executeSubSteps(
+    browser,
+    matchedSteps,
+    runbook,
+    config,
+    opts,
+    debugLogger,
+    pauseMs,
+    logger,
+    snapshotCache,
+    contextChunker,
+    failureRegistry
+  );
+  debugLogger.log({
+    phase: "executor",
+    event: "branch_end",
+    step: step.ordinal,
+    data: { match: matchLabel, failed }
+  });
+  return {
+    ordinal: step.ordinal,
+    description: step.description,
+    actionType: "branch",
+    status: failed ? "failed" : "success",
+    durationMs: Date.now() - start,
+    branchMatch: matchLabel,
+    subStepResults: [subResults]
+  };
+}
+async function executeStep(browser, step, runbook, config, opts, debugLogger, logger, snapshotCache, contextChunker, failureRegistry) {
+  const start = Date.now();
+  if (opts.skills?.length && step.url) {
+    const stepContext = {
+      actionType: step.action.type,
+      memoryOperations: step.memoryOperations
+    };
+    const hasActiveSkill = opts.skills.some(
+      (s) => s.shouldActivateForStep ? s.shouldActivateForStep(step.url, stepContext) : s.shouldActivate(step.url)
+    );
+    if (hasActiveSkill) {
+      try {
+        const snap = await browser.snapshot();
+        const skillResult = await applySkillTransform(browser, snap, step.url, opts.skills, stepContext);
+        if (skillResult?.extractedData) {
+          opts.store.set("extractedData", skillResult.extractedData);
+        }
+      } catch {
+      }
+    }
+  }
+  if (step.action.type === "navigate") {
+    const rawUrl = step.action.url ?? step.url;
+    const url = opts.store.resolveTemplate(rawUrl);
+    logger.step(`Navigate: ${opts.store.maskSensitive(url)}`);
+    const maxNavRetries = 2;
+    for (let navAttempt = 0; ; navAttempt++) {
+      await browser.navigate(url);
+      const pageCount = await browser.pageCount();
+      await browser.waitForPossibleNavigation(await browser.url(), pageCount);
+      const currentUrl = await browser.url();
+      if (!currentUrl.startsWith("chrome-error://")) break;
+      if (navAttempt >= maxNavRetries) {
+        logger.warn(tf("executor.chromeErrorDetected", { url }));
+        throw new Error(`Navigation failed: page landed on chrome-error:// (target: ${url})`);
+      }
+      logger.warn(tf("executor.chromeErrorDetected", { url }) + ` \u2014 retrying (${navAttempt + 1}/${maxNavRetries})`);
+      await sleep(2e3 * (navAttempt + 1));
+    }
+    return { status: "success", durationMs: Date.now() - start };
+  }
+  if (step.action.type === "scroll") {
+    logger.step("Scroll: down");
+    await browser.scroll("down");
+    return { status: "success", durationMs: Date.now() - start };
+  }
+  if (step.action.type === "wait") {
+    const rawMs = step.action.value ? opts.store.resolveTemplate(step.action.value) : String(runbook.settings.defaultTimeout);
+    const ms = Number(rawMs);
+    logger.step(`Wait: ${ms}ms`);
+    await browser.wait(ms);
+    return { status: "success", durationMs: Date.now() - start };
+  }
+  if (step.action.type === "extract") {
+    const script = opts.store.resolveTemplate(step.action.script ?? step.action.value ?? "");
+    if (!script) {
+      return { status: "failed", durationMs: Date.now() - start, error: "extract requires script or value" };
+    }
+    logger.step(`Extract: executing script`);
+    debugLogger.log({
+      phase: "executor",
+      event: "extract",
+      step: step.ordinal,
+      data: { script: script.slice(0, 200) }
+    });
+    const result = await browser.evaluate(script);
+    const isArray = Array.isArray(result);
+    const stringifyApplied = typeof result !== "string" && result !== null && result !== void 0;
+    const resultStr = result === null || result === void 0 ? "" : typeof result === "string" ? result : JSON.stringify(result);
+    debugLogger.log({
+      phase: "executor",
+      event: "extract_result",
+      step: step.ordinal,
+      data: {
+        resultType: result === null ? "null" : typeof result,
+        isArray,
+        arrayLength: isArray ? result.length : void 0,
+        resultPreview: resultStr.slice(0, 200),
+        storedLength: resultStr.length,
+        stringifyApplied
+      }
+    });
+    if (resultStr === "") {
+      logger.warn("Extract returned empty result");
+      debugLogger.log({
+        phase: "executor",
+        event: "extract_empty_result",
+        step: step.ordinal,
+        data: { script: script.slice(0, 200) }
+      });
+    }
+    return { status: "success", durationMs: Date.now() - start, extractedData: resultStr };
+  }
+  if (step.action.type === "export") {
+    if (!opts.dataStore) {
+      return { status: "failed", durationMs: Date.now() - start, error: "export requires dataStore" };
+    }
+    const collection = opts.store.resolveTemplate(step.action.exportCollection ?? "default");
+    const format = step.action.exportFormat ?? "csv";
+    const outputDir = config.outputDir ?? "/tmp";
+    const exportPath = opts.store.resolveTemplate(
+      step.action.exportPath ?? `${outputDir}/${collection}.${format}`
+    );
+    logger.step(`Export: ${collection} \u2192 ${exportPath} (${format})`);
+    const exportItems = opts.dataStore.getAll(collection);
+    const sampleKeys = exportItems.length > 0 ? JSON.stringify(Object.keys(exportItems[0])) : "N/A";
+    debugLogger.log({
+      phase: "executor",
+      event: "export",
+      step: step.ordinal,
+      data: {
+        collection,
+        itemCount: exportItems.length,
+        format,
+        path: exportPath,
+        sampleKeys
+      }
+    });
+    await opts.dataStore.writeToFile(collection, exportPath, format);
+    if (opts.downloadManager) {
+      opts.downloadManager.addDownload({
+        path: exportPath,
+        filename: exportPath.split("/").pop() ?? "unknown",
+        stepOrdinal: step.ordinal,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return { status: "success", durationMs: Date.now() - start, exportedFile: exportPath };
+  }
+  if (step.action.type === "download" && !step.action.selector) {
+    const downloadPath = opts.store.resolveTemplate(
+      step.action.downloadPath ?? `/tmp/download-${Date.now()}.bin`
+    );
+    logger.step(`Download: waiting for download \u2192 ${downloadPath}`);
+    await browser.waitForDownload(downloadPath);
+    if (opts.downloadManager) {
+      opts.downloadManager.addDownload({
+        path: downloadPath,
+        filename: downloadPath.split("/").pop() ?? "unknown",
+        stepOrdinal: step.ordinal,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return { status: "success", durationMs: Date.now() - start, downloadedFile: downloadPath };
+  }
+  if (step.action.type === "memory") {
+    logger.step(`Memory operation: ${step.description}`);
+    return { status: "success", durationMs: Date.now() - start };
+  }
+  if (step.action.type === "key") {
+    const keys = opts.store.resolveTemplate(step.action.keys ?? step.action.value ?? "");
+    if (!keys) {
+      return { status: "failed", durationMs: Date.now() - start, error: "key action requires keys or value" };
+    }
+    logger.step(`Key: ${keys}`);
+    await browser.pressKeys(keys);
+    return { status: "success", durationMs: Date.now() - start };
+  }
+  if (step.memoryOperations && step.memoryOperations.length > 0 && !step.action.selector) {
+    logger.warn(
+      `Step has memoryOperations but action type "${step.action.type}" with no selector \u2014 treating as memory-only`
+    );
+    debugLogger.log({
+      phase: "executor",
+      event: "memory_fallback",
+      step: step.ordinal,
+      data: { originalActionType: step.action.type, memoryOpsCount: step.memoryOperations.length }
+    });
+    return { status: "success", durationMs: Date.now() - start };
+  }
+  if (!step.action.selector) {
+    return {
+      status: "failed",
+      durationMs: Date.now() - start,
+      error: "No selector defined for this step",
+      diagnostics: {
+        stepAction: {
+          type: step.action.type,
+          value: step.action.value,
+          url: step.action.url
+        },
+        stepUrl: step.url
+      }
+    };
+  }
+  const defaultStrategy = {
+    maxRetries: 3,
+    changeTimeouts: [8e3, 1e4],
+    finalRetryStabilizeMs: 3e3,
+    domStabilityMs: 5e3
+  };
+  const strategy = config.executionStrategy ?? defaultStrategy;
+  const { maxRetries } = strategy;
+  let aiResult = null;
+  let lastSnapshot = "";
+  let lastRefs;
+  let prevSnapshot = "";
+  let lastAiResponseText = "";
+  let lastAiPrompt = "";
+  let attempts = 0;
+  const failureHistory = [];
+  const retryDetails = [];
+  let cachedRefUsed = false;
+  let deterministicResolveResult = "";
+  let agentFallbackResult;
+  let visionFallbackResult;
+  let resolveMethod = null;
+  let deterministicMatchType;
+  let deterministicConfidence;
+  let failureHintsProvided = false;
+  if (opts.selectorCache && step.action.selector) {
+    const cacheKey = buildCacheKey(step.ordinal, step.url, step.action.selector);
+    const cached = lookupCache(opts.selectorCache, cacheKey);
+    if (cached) {
+      cachedRefUsed = true;
+      const snapshotResult = await browser.snapshotWithRefs();
+      const snapshot = snapshotResult.tree;
+      lastSnapshot = snapshot;
+      lastRefs = snapshotResult.refs;
+      prevSnapshot = snapshot;
+      if (findElementInSnapshot(snapshot, cached.ref) !== null) {
+        updateCache(opts.selectorCache, cacheKey, cached.ref, buildSnapshotHash(snapshot));
+        aiResult = { ref: cached.ref, aiResponseText: "(cache hit)", reasoning: "cache hit" };
+        resolveMethod = "cache";
+        debugLogger.log({
+          phase: "executor",
+          event: "selector_cache_hit",
+          step: step.ordinal,
+          data: { cacheKey, ref: cached.ref, hitCount: cached.hitCount + 1 }
+        });
+        logger.success(`Cache hit: @${cached.ref}`);
+      } else {
+        invalidateCacheEntry(opts.selectorCache, cacheKey);
+        debugLogger.log({
+          phase: "executor",
+          event: "selector_cache_stale",
+          step: step.ordinal,
+          data: { cacheKey, ref: cached.ref }
+        });
+        logger.warn(`Cache stale: @${cached.ref} not found in snapshot, falling back to AI`);
+        cachedRefUsed = false;
+      }
+    }
+  }
+  if (!aiResult && step.action.selector) {
+    if (!lastSnapshot) {
+      const currentUrl = await browser.url();
+      if (currentUrl.startsWith("chrome-error://")) {
+        logger.warn(tf("executor.chromeErrorDetected", { url: step.url }));
+        await browser.navigate(step.url);
+        await browser.waitForDOMStability(3e3);
+      }
+      await browser.waitForDOMStability(strategy.domStabilityMs);
+      const snapshotResult = await browser.snapshotWithRefs();
+      lastSnapshot = snapshotResult.tree;
+      lastRefs = snapshotResult.refs;
+      prevSnapshot = lastSnapshot;
+      debugLogger.log({
+        phase: "executor",
+        event: "initial_snapshot",
+        step: step.ordinal,
+        data: {
+          url: await browser.url(),
+          elementCount: countSnapshotElements(lastSnapshot),
+          snapshotLength: lastSnapshot.length
+        }
+      });
+      if (countSnapshotElements(lastSnapshot) === 0) {
+        debugLogger.log({
+          phase: "executor",
+          event: "empty_snapshot_recovery",
+          step: step.ordinal,
+          data: { url: await browser.url(), attempt: "initial" }
+        });
+        logger.warn("Empty snapshot detected, waiting for DOM stability...");
+        await sleep(1e3);
+        await browser.waitForDOMStability(strategy.domStabilityMs);
+        const retryResult = await browser.snapshotWithRefs();
+        lastSnapshot = retryResult.tree;
+        lastRefs = retryResult.refs;
+        prevSnapshot = lastSnapshot;
+      }
+    }
+    const deterministicResult = resolveDeterministic(lastSnapshot, step.action.selector, lastRefs);
+    if (deterministicResult.ref) {
+      aiResult = {
+        ref: deterministicResult.ref,
+        aiResponseText: `(deterministic: ${deterministicResult.matchType}, confidence=${deterministicResult.confidence})`,
+        reasoning: `deterministic match: ${deterministicResult.matchType}`
+      };
+      resolveMethod = "deterministic";
+      deterministicMatchType = deterministicResult.matchType ?? void 0;
+      deterministicConfidence = deterministicResult.confidence;
+      debugLogger.log({
+        phase: "executor",
+        event: "deterministic_resolve",
+        step: step.ordinal,
+        data: {
+          ref: deterministicResult.ref,
+          matchType: deterministicResult.matchType,
+          confidence: deterministicResult.confidence,
+          selector: step.action.selector
+        }
+      });
+      deterministicResolveResult = `hit: @${deterministicResult.ref} (${deterministicResult.matchType}, confidence=${deterministicResult.confidence})`;
+      logger.success(`Deterministic resolve: @${deterministicResult.ref} (${deterministicResult.matchType}, confidence=${deterministicResult.confidence})`);
+    } else {
+      deterministicResolveResult = "miss: no match";
+      debugLogger.log({
+        phase: "executor",
+        event: "deterministic_resolve_miss",
+        step: step.ordinal,
+        data: { selector: step.action.selector }
+      });
+    }
+  }
+  for (let attempt = 0; attempt <= maxRetries && !aiResult; attempt++) {
+    if (attempt > 0) {
+      logger.warn(`Selector not found, retrying (${attempt}/${maxRetries})...`);
+      if (attempt <= strategy.changeTimeouts.length) {
+        const timeout = strategy.changeTimeouts[attempt - 1];
+        logger.info(`Waiting up to ${timeout / 1e3}s for page transition...`);
+        const changeResult = await browser.waitForSnapshotChange(lastSnapshot, timeout);
+        if (changeResult.changed) {
+          logger.success("Page transition detected");
+          lastSnapshot = changeResult.snapshot;
+        } else {
+          debugLogger.log({
+            phase: "executor",
+            event: "snapshot_unchanged",
+            step: step.ordinal,
+            data: { attempt, strategy: "waitForSnapshotChange", timeoutMs: timeout }
+          });
+          if (countSnapshotElements(lastSnapshot) === 0) {
+            logger.warn("No page transition detected but snapshot is empty, attempting recovery...");
+          } else {
+            logger.warn("No page transition detected, skipping AI call");
+            const reason2 = `Attempt ${attempt}: waited ${timeout / 1e3}s for page transition, no change`;
+            failureHistory.push(reason2);
+            retryDetails.push({
+              attempt,
+              snapshotChanged: false,
+              snapshotElementCount: countSnapshotElements(lastSnapshot),
+              failureReason: reason2
+            });
+            prevSnapshot = lastSnapshot;
+            attempts = attempt + 1;
+            continue;
+          }
+        }
+      } else {
+        await sleep(strategy.finalRetryStabilizeMs);
+        await browser.waitForDOMStability(strategy.domStabilityMs);
+        lastSnapshot = await browser.snapshot();
+      }
+    } else {
+      if (!lastSnapshot) {
+        lastSnapshot = await browser.snapshot();
+      }
+    }
+    if (countSnapshotElements(lastSnapshot) === 0) {
+      debugLogger.log({
+        phase: "executor",
+        event: "empty_snapshot_recovery",
+        step: step.ordinal,
+        data: { url: await browser.url(), attempt }
+      });
+      logger.warn(`Snapshot empty (attempt ${attempt}), forcing DOM stability wait...`);
+      await sleep(1e3);
+      await browser.waitForDOMStability(strategy.domStabilityMs);
+      const freshResult = await browser.snapshotWithRefs();
+      lastSnapshot = freshResult.tree;
+      lastRefs = freshResult.refs;
+    }
+    const snapshotChanged = attempt === 0 || lastSnapshot !== prevSnapshot;
+    debugLogger.log({
+      phase: "executor",
+      event: attempt > 0 ? "selector_retry" : "snapshot",
+      step: step.ordinal,
+      data: {
+        url: step.url,
+        snapshot: lastSnapshot,
+        attempt,
+        ...attempt > 0 ? { snapshotChanged } : {}
+      }
+    });
+    const failureHints = failureRegistry && step.action.selector ? failureRegistry.getRelevantHints(step.url, step.action.selector) : void 0;
+    if (failureHints) failureHintsProvided = true;
+    const retryContext = attempt > 0 ? {
+      attempt,
+      previousAiResponse: lastAiResponseText || void 0,
+      snapshotChanged,
+      failureHistory,
+      failureHints
+    } : void 0;
+    const skillResult = await applySkillTransform(browser, lastSnapshot, step.url, opts.skills);
+    if (skillResult?.extractedData) {
+      opts.store.set("extractedData", skillResult.extractedData);
+    }
+    const filteredSnap = skillResult?.snapshot ?? (snapshotCache ? snapshotCache.getFiltered(lastSnapshot) : lastSnapshot);
+    const relevantContext = contextChunker ? contextChunker.selectRelevant(step.description, step.url) : config.contextMarkdown;
+    const detailed = await resolveWithAIDetailed(
+      filteredSnap,
+      step.action.selector,
+      step.description,
+      step.url,
+      relevantContext,
+      debugLogger,
+      retryContext,
+      opts.store.getWorkingMemorySummary(),
+      opts.aiProvider
+    );
+    attempts = attempt + 1;
+    lastAiResponseText = detailed.aiResponseText;
+    lastAiPrompt = detailed.prompt ?? "";
+    prevSnapshot = lastSnapshot;
+    if (detailed.ref) {
+      aiResult = detailed;
+      resolveMethod = "ai";
+      break;
+    }
+    const reason = `Attempt ${attempt + 1}: AI returned empty ref`;
+    failureHistory.push(reason);
+    retryDetails.push({
+      attempt,
+      snapshotChanged,
+      snapshotElementCount: countSnapshotElements(lastSnapshot),
+      failureReason: reason,
+      aiReasoning: detailed.reasoning || void 0,
+      aiPrompt: detailed.prompt?.slice(0, 2e3),
+      aiResponse: detailed.aiResponseText?.slice(0, 1e3),
+      snapshotPreview: lastSnapshot.slice(0, 2e3)
+    });
+  }
+  if (!aiResult) {
+    debugLogger.log({
+      phase: "executor",
+      event: "recovery_attempt",
+      step: step.ordinal,
+      data: { strategy: "scroll_down" }
+    });
+    logger.warn("All retries failed, attempting scroll recovery...");
+    try {
+      await browser.scroll("down", 500);
+      await browser.waitForDOMStability(3e3);
+      const scrolledSnapshot = await browser.snapshot();
+      if (scrolledSnapshot !== lastSnapshot) {
+        const scrollSkillResult = await applySkillTransform(browser, scrolledSnapshot, step.url, opts.skills);
+        if (scrollSkillResult?.extractedData) {
+          opts.store.set("extractedData", scrollSkillResult.extractedData);
+        }
+        const filteredScrollSnap = scrollSkillResult?.snapshot ?? (snapshotCache ? snapshotCache.getFiltered(scrolledSnapshot) : scrolledSnapshot);
+        const relevantCtx = contextChunker ? contextChunker.selectRelevant(step.description, step.url) : config.contextMarkdown;
+        const recoveryResult = await resolveWithAIDetailed(
+          filteredScrollSnap,
+          step.action.selector,
+          step.description,
+          step.url,
+          relevantCtx,
+          debugLogger,
+          {
+            attempt: attempts,
+            snapshotChanged: true,
+            failureHistory: [...failureHistory, "Scroll recovery attempt"],
+            failureHints: failureRegistry && step.action.selector ? failureRegistry.getRelevantHints(step.url, step.action.selector) : void 0
+          },
+          opts.store.getWorkingMemorySummary(),
+          opts.aiProvider
+        );
+        attempts++;
+        lastAiResponseText = recoveryResult.aiResponseText;
+        lastAiPrompt = recoveryResult.prompt ?? "";
+        lastSnapshot = scrolledSnapshot;
+        if (recoveryResult.ref) {
+          aiResult = recoveryResult;
+          resolveMethod = "scroll";
+          logger.success("Scroll recovery succeeded");
+          if (failureRegistry && step.action.selector) {
+            failureRegistry.record(step.url, step.action.selector, "element_not_found", step.ordinal, { method: "scroll" });
+          }
+        } else {
+          retryDetails.push({
+            attempt: attempts - 1,
+            snapshotChanged: true,
+            snapshotElementCount: countSnapshotElements(scrolledSnapshot),
+            failureReason: "Scroll recovery: AI returned empty ref",
+            aiReasoning: recoveryResult.reasoning || void 0,
+            aiPrompt: recoveryResult.prompt?.slice(0, 2e3),
+            aiResponse: recoveryResult.aiResponseText?.slice(0, 1e3),
+            snapshotPreview: scrolledSnapshot.slice(0, 2e3)
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  if (!aiResult && config.enableVisionFallback) {
+    logger.warn("Attempting vision fallback (screenshot-based)...");
+    try {
+      const { imageBuffer, annotations } = await browser.screenshotWithAnnotations();
+      const visionResult = await resolveWithVision(
+        imageBuffer,
+        annotations,
+        step.action.selector,
+        step.description,
+        step.url,
+        failureHistory,
+        debugLogger,
+        opts.aiProvider
+      );
+      if (visionResult?.ref) {
+        aiResult = {
+          ref: visionResult.ref,
+          aiResponseText: `(vision: confidence=${visionResult.confidence})`,
+          reasoning: visionResult.reasoning
+        };
+        resolveMethod = "vision";
+        visionFallbackResult = {
+          annotationCount: annotations.length,
+          reasoning: visionResult.reasoning,
+          success: true
+        };
+        logger.success(`Vision fallback succeeded: @${visionResult.ref}`);
+        if (failureRegistry && step.action.selector) {
+          failureRegistry.record(step.url, step.action.selector, "element_not_found", step.ordinal, { method: "vision" });
+        }
+      } else {
+        visionFallbackResult = {
+          annotationCount: annotations.length,
+          reasoning: visionResult?.reasoning ?? "no match",
+          success: false
+        };
+        failureHistory.push("Vision fallback: no matching element");
+      }
+    } catch (error) {
+      failureHistory.push(`Vision fallback error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (!aiResult && config.enableAgentFallback) {
+    debugLogger.log({
+      phase: "executor",
+      event: "agent_fallback_start",
+      step: step.ordinal,
+      data: { failureHistory }
+    });
+    logger.warn("Attempting agent fallback...");
+    const fallbackContext = contextChunker ? contextChunker.selectRelevant(step.description, step.url) : config.contextMarkdown;
+    const fallbackResult = await runGoalAgent(
+      browser,
+      { description: step.description, action: step.action },
+      failureHistory,
+      fallbackContext,
+      debugLogger,
+      opts.aiProvider
+    );
+    debugLogger.log({
+      phase: "executor",
+      event: "agent_fallback_result",
+      step: step.ordinal,
+      data: fallbackResult
+    });
+    agentFallbackResult = {
+      strategy: fallbackResult.alternativeStrategy,
+      analysis: fallbackResult.analysis,
+      reasoning: fallbackResult.reasoning,
+      success: fallbackResult.success
+    };
+    if (fallbackResult.success && fallbackResult.alternativeRef) {
+      aiResult = {
+        ref: fallbackResult.alternativeRef,
+        aiResponseText: JSON.stringify(fallbackResult),
+        reasoning: fallbackResult.reasoning
+      };
+      resolveMethod = "agent";
+      logger.success(`Agent fallback succeeded: @${fallbackResult.alternativeRef} (${fallbackResult.alternativeStrategy})`);
+      if (failureRegistry && step.action.selector) {
+        failureRegistry.record(step.url, step.action.selector, "element_not_found", step.ordinal, { method: `agent:${fallbackResult.alternativeStrategy}` });
+      }
+    } else {
+      logger.warn(`Agent fallback: ${fallbackResult.alternativeStrategy} \u2014 ${fallbackResult.analysis}`);
+    }
+  }
+  const retryCount = attempts > 1 ? attempts - 1 : 0;
+  if (!aiResult) {
+    const elementCount = countSnapshotElements(lastSnapshot);
+    const selectorInfo = JSON.stringify(step.action.selector);
+    const aiExcerpt = lastAiResponseText.slice(0, 200);
+    const failureCategory = classifyFailure({
+      error: `Could not resolve selector after ${attempts} attempts`,
+      selectorResolved: false,
+      actionExecuted: false,
+      retryDetails,
+      cachedRefUsed
+    });
+    if (failureRegistry && step.action.selector) {
+      failureRegistry.record(step.url, step.action.selector, failureCategory, step.ordinal);
+    }
+    return {
+      status: "failed",
+      durationMs: Date.now() - start,
+      error: `Could not resolve selector after ${attempts} attempts (elements: ${elementCount}, selector: ${selectorInfo}, AI: "${aiExcerpt}")`,
+      retryCount,
+      retryDetails,
+      failureCategory,
+      diagnostics: {
+        lastSnapshotPreview: lastSnapshot.slice(0, 2e3),
+        failureHistory,
+        lastAiResponseText,
+        recoveryHint: getRecoveryHint(failureCategory),
+        deterministicResolveResult: deterministicResolveResult || void 0,
+        visionFallbackResult,
+        agentFallbackResult,
+        executionStrategy: strategy,
+        stepAction: {
+          type: step.action.type,
+          selector: step.action.selector,
+          value: step.action.value,
+          url: step.action.url
+        },
+        stepUrl: step.url
+      },
+      // テレメトリフィールド
+      resolveMethod,
+      deterministicMatchType,
+      deterministicConfidence,
+      contextChunksUsed: contextChunker?.lastSelectedCount ?? 0,
+      failureHintsProvided,
+      workingMemoryTokens: opts.store.getWorkingMemorySummary() ? Math.ceil(opts.store.getWorkingMemorySummary().length / 4) : 0,
+      snapshotElementCount: elementCount
+    };
+  }
+  debugLogger.log({
+    phase: "executor",
+    event: "selector_resolve",
+    step: step.ordinal,
+    data: { selector: step.action.selector, resolvedRef: aiResult.ref, url: step.url, attempts, resolveMethod }
+  });
+  if (opts.selectorCache && step.action.selector) {
+    const cacheKey = buildCacheKey(step.ordinal, step.url, step.action.selector);
+    updateCache(opts.selectorCache, cacheKey, aiResult.ref, buildSnapshotHash(lastSnapshot));
+  }
+  if (resolveMethod !== "cache" && resolveMethod !== "deterministic") {
+    logger.success(`AI resolved: @${aiResult.ref}${attempts > 1 ? ` (after ${attempts} attempts)` : ""}`);
+  }
+  const ref = `@${aiResult.ref}`;
+  const value = resolveValue(step, opts.store);
+  const optionText = step.action.optionText ? opts.store.resolveTemplate(step.action.optionText) : void 0;
+  if (!lastRefs) {
+    const freshResult = await browser.snapshotWithRefs();
+    lastSnapshot = freshResult.tree;
+    lastRefs = freshResult.refs;
+  }
+  let validation = validateAction(lastSnapshot, aiResult.ref, step.action.type, value, lastRefs);
+  if (validation.warnings.length > 0) {
+    for (const w of validation.warnings) {
+      logger.warn(`Validation warning: ${w.message}`);
+    }
+    debugLogger.log({
+      phase: "executor",
+      event: "validation_warnings",
+      step: step.ordinal,
+      data: { warnings: validation.warnings }
+    });
+  }
+  if (!validation.valid) {
+    const hasTypeMismatch = validation.errors.some((e) => e.code === "type_mismatch");
+    if (hasTypeMismatch) {
+      debugLogger.log({
+        phase: "executor",
+        event: "validation_retry",
+        step: step.ordinal,
+        data: { errors: validation.errors, ref: aiResult.ref, actionType: step.action.type }
+      });
+      logger.warn("Validation failed with type_mismatch, retrying with fresh snapshot...");
+      await browser.waitForDOMStability(2e3);
+      const freshResult = await browser.snapshotWithRefs();
+      if (freshResult.refs[aiResult.ref]) {
+        lastSnapshot = freshResult.tree;
+        lastRefs = freshResult.refs;
+        validation = validateAction(lastSnapshot, aiResult.ref, step.action.type, value, lastRefs);
+        if (validation.warnings.length > 0) {
+          for (const w of validation.warnings) {
+            logger.warn(`Validation warning (retry): ${w.message}`);
+          }
+        }
+      }
+    }
+    if (!validation.valid) {
+      const errorMessages = validation.errors.map((e) => e.message).join("; ");
+      debugLogger.log({
+        phase: "executor",
+        event: "validation_failed",
+        step: step.ordinal,
+        data: { errors: validation.errors, ref: aiResult.ref, actionType: step.action.type }
+      });
+      return {
+        status: "failed",
+        durationMs: Date.now() - start,
+        error: `Pre-execution validation failed: ${errorMessages}`,
+        retryCount,
+        retryDetails: retryDetails.length > 0 ? retryDetails : void 0,
+        diagnostics: {
+          lastSnapshotPreview: lastSnapshot.slice(0, 2e3),
+          failureHistory,
+          lastAiResponseText,
+          validationErrors: validation.errors.map((e) => `[${e.code}] ${e.message}`),
+          validationWarnings: validation.warnings.map((w) => `[${w.code}] ${w.message}`),
+          executionStrategy: strategy,
+          stepAction: {
+            type: step.action.type,
+            selector: step.action.selector,
+            value: step.action.value,
+            url: step.action.url
+          },
+          stepUrl: step.url
+        },
+        // テレメトリフィールド
+        resolveMethod,
+        deterministicMatchType,
+        deterministicConfidence,
+        contextChunksUsed: contextChunker?.lastSelectedCount ?? 0,
+        failureHintsProvided,
+        snapshotElementCount: countSnapshotElements(lastSnapshot)
+      };
+    }
+    logger.success("Validation retry succeeded");
+  }
+  const displayValue = value ? opts.store.maskSensitive(value) : value;
+  const urlBefore = await browser.url();
+  const pageCountBefore = await browser.pageCount();
+  switch (step.action.type) {
+    case "click":
+      logger.step(`Click: ${ref}`);
+      await browser.click(ref);
+      break;
+    case "input":
+      logger.step(`Input: ${ref} = "${displayValue ?? ""}"`);
+      await browser.fill(ref, value ?? "");
+      break;
+    case "select": {
+      const displayOptionText = optionText ? opts.store.maskSensitive(optionText) : void 0;
+      logger.step(`Select: ${ref} = "${displayOptionText ?? displayValue ?? ""}"`);
+      await browser.select(ref, optionText ?? value ?? "");
+      break;
+    }
+    case "hover":
+      logger.step(`Hover (click fallback): ${ref}`);
+      await browser.click(ref);
+      break;
+    case "download": {
+      const downloadPath = opts.store.resolveTemplate(
+        step.action.downloadPath ?? `/tmp/download-${Date.now()}.bin`
+      );
+      logger.step(`Download: ${ref} \u2192 ${downloadPath}`);
+      await browser.download(ref, downloadPath);
+      if (opts.downloadManager) {
+        opts.downloadManager.addDownload({
+          path: downloadPath,
+          filename: downloadPath.split("/").pop() ?? "unknown",
+          stepOrdinal: step.ordinal,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      return {
+        status: "success",
+        durationMs: Date.now() - start,
+        downloadedFile: downloadPath,
+        retryCount,
+        retryDetails: retryDetails.length > 0 ? retryDetails : void 0
+      };
+    }
+  }
+  if (step.action.type === "click") {
+    await browser.waitForPossibleNavigation(urlBefore, pageCountBefore);
+    const maxClickRetries = 2;
+    let clickRetryUrl = await browser.url();
+    for (let clickAttempt = 0; clickRetryUrl.startsWith("chrome-error://"); clickAttempt++) {
+      if (clickAttempt >= maxClickRetries) {
+        logger.warn(tf("executor.chromeErrorDetected", { url: urlBefore }));
+        throw new Error(`Navigation failed: page landed on chrome-error:// (from: ${urlBefore})`);
+      }
+      logger.warn(tf("executor.chromeErrorDetected", { url: urlBefore }) + ` \u2014 retrying click (${clickAttempt + 1}/${maxClickRetries})`);
+      await browser.navigate(urlBefore);
+      await browser.waitForDOMStability(3e3);
+      await sleep(2e3 * (clickAttempt + 1));
+      await browser.click(ref);
+      await browser.waitForPossibleNavigation(urlBefore, await browser.pageCount());
+      clickRetryUrl = await browser.url();
+    }
+  }
+  const durationMs = Date.now() - start;
+  debugLogger.log({
+    phase: "executor",
+    event: "action",
+    step: step.ordinal,
+    data: {
+      type: step.action.type,
+      ref,
+      value: displayValue,
+      status: "success",
+      durationMs
+    }
+  });
+  const workingMemorySummary = opts.store.getWorkingMemorySummary();
+  return {
+    status: "success",
+    durationMs,
+    retryCount,
+    retryDetails: retryDetails.length > 0 ? retryDetails : void 0,
+    // テレメトリフィールド
+    resolveMethod,
+    deterministicMatchType,
+    deterministicConfidence,
+    contextChunksUsed: contextChunker?.lastSelectedCount ?? 0,
+    failureHintsProvided,
+    workingMemoryTokens: workingMemorySummary ? Math.ceil(workingMemorySummary.length / 4) : 0,
+    snapshotElementCount: lastSnapshot ? countSnapshotElements(lastSnapshot) : 0
+  };
+}
+async function executeMemoryOperations(step, store, dataStore, debugLogger, logger) {
+  if (!step.memoryOperations) return;
+  for (const op of step.memoryOperations) {
+    if (op.type === "append") {
+      if (!op.source) {
+        logger.warn(`Memory append: source is required`);
+        continue;
+      }
+      const rawValue = store.get(op.source);
+      if (!rawValue) {
+        logger.warn(`Memory append: variable "${op.source}" not found in store`);
+        continue;
+      }
+      parseAndAppendToMemory(rawValue, {
+        dataStore,
+        debugLogger,
+        phase: "executor",
+        step: step.ordinal,
+        collection: op.collection
+      });
+    } else if (op.type === "aggregate") {
+      if (!op.field || !op.operation || !op.outputVariable) {
+        logger.warn(`Memory aggregate: field, operation, and outputVariable are required`);
+        continue;
+      }
+      const result = dataStore.aggregate({
+        collection: op.collection,
+        field: op.field,
+        operation: op.operation
+      });
+      store.set(op.outputVariable, result);
+      logger.success(`Memory: ${op.operation}(${op.collection}.${op.field}) = "${result}" \u2192 {{${op.outputVariable}}}`);
+      debugLogger.log({
+        phase: "executor",
+        event: "memory_aggregate",
+        step: step.ordinal,
+        data: { collection: op.collection, field: op.field, operation: op.operation, result, outputVariable: op.outputVariable }
+      });
+    }
+  }
+}
+function resolveValue(step, store) {
+  const rawValue = step.action.value;
+  if (rawValue === void 0) return void 0;
+  return store.resolveTemplate(rawValue);
+}
+function countSnapshotElements(snapshot) {
+  return countElements(snapshot);
+}
+
+// src/runbook-executor/input-collector.ts
+import { z as z5 } from "zod";
+var contextValuesSchema = z5.object({
+  values: z5.record(z5.string(), z5.string()).describe("\u5909\u6570\u540D\u2192\u62BD\u51FA\u5024\u306E\u30DE\u30C3\u30D7")
+});
+var CONTEXT_EXTRACTION_SYSTEM_PROMPT = [
+  "\u4EE5\u4E0B\u306E\u5909\u6570\u30EA\u30B9\u30C8\u3068 context markdown \u304C\u4E0E\u3048\u3089\u308C\u307E\u3059\u3002",
+  "context \u304B\u3089\u5404\u5909\u6570\u306B\u5BFE\u5FDC\u3059\u308B\u5024\u3092\u62BD\u51FA\u3057\u3066\u304F\u3060\u3055\u3044\u3002",
+  "\u5024\u304C\u898B\u3064\u304B\u3089\u306A\u3044\u5834\u5408\u306F\u305D\u306E\u30AD\u30FC\u3092\u542B\u3081\u306A\u3044\u3067\u304F\u3060\u3055\u3044\u3002"
+].join("\n");
+async function extractValuesFromContext(inputs, contextMarkdown, aiProvider) {
+  const inputDescriptions = inputs.map((i) => `- name: "${i.name}", description: "${i.description}"`).join("\n");
+  const userPrompt = [
+    "## \u5909\u6570",
+    inputDescriptions,
+    "",
+    "## Context",
+    contextMarkdown
+  ].join("\n");
+  try {
+    const model = aiProvider ? aiProvider.getModel("extraction") : getModel("extraction");
+    const { object } = await withAIRetry(
+      () => trackedGenerateObject("extraction", {
+        model,
+        messages: [
+          {
+            role: "system",
+            content: CONTEXT_EXTRACTION_SYSTEM_PROMPT,
+            providerOptions: {
+              anthropic: { cacheControl: { type: "ephemeral" } }
+            }
+          },
+          { role: "user", content: userPrompt }
+        ],
+        schema: contextValuesSchema,
+        temperature: 0
+      }),
+      { label: "input-collect" }
+    );
+    return object.values;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[input-collector] Context extraction failed: ${msg}`);
+    return {};
+  }
+}
+
+// src/runbook-executor/execution-planner.ts
+function mergeVariablesAndSecrets(variables, secrets) {
+  const mergedValues = { ...variables };
+  const sensitiveKeys = /* @__PURE__ */ new Set();
+  if (secrets) {
+    for (const [k, v] of Object.entries(secrets.values)) {
+      mergedValues[k] = v;
+      sensitiveKeys.add(k);
+    }
+    for (const k of secrets.keys) sensitiveKeys.add(k);
+  }
+  return { mergedValues, sensitiveKeys };
+}
+async function resolveVariablesCore(runbook, input) {
+  const variables = runbook.variables ?? {};
+  const values = /* @__PURE__ */ new Map();
+  const sensitiveKeys = /* @__PURE__ */ new Set();
+  const unresolvedDataVars = [];
+  const captureVars = [];
+  function collectCaptureVars(steps) {
+    for (const step of steps) {
+      if (step.captures) {
+        for (const c of step.captures) {
+          captureVars.push(c.name);
+        }
+      }
+      if (step.steps) {
+        collectCaptureVars(step.steps);
+      }
+      if (step.branches) {
+        for (const branchCase of step.branches.cases) {
+          collectCaptureVars(branchCase.steps);
+        }
+        if (step.branches.default) {
+          collectCaptureVars(step.branches.default.steps);
+        }
+      }
+    }
+  }
+  collectCaptureVars(runbook.steps);
+  for (const [name, def] of Object.entries(variables)) {
+    if (def.sensitive) {
+      sensitiveKeys.add(name);
+    }
+  }
+  const secretsKeys = /* @__PURE__ */ new Set();
+  if (input.secrets) {
+    for (const [key, val] of Object.entries(input.secrets.values)) {
+      values.set(key, val);
+      sensitiveKeys.add(key);
+      secretsKeys.add(key);
+    }
+  }
+  for (const [name, def] of Object.entries(variables)) {
+    if (def.source === "data" && !values.has(name)) {
+      unresolvedDataVars.push(name);
+    }
+  }
+  const unresolvedVars = Object.entries(variables).filter(
+    ([name]) => !values.has(name) && !unresolvedDataVars.includes(name)
+  );
+  const contextExtractedKeys = /* @__PURE__ */ new Set();
+  if (unresolvedVars.length > 0) {
+    const extracted = await extractValuesFromContext(
+      unresolvedVars.map(([name, def]) => ({
+        name,
+        description: def.description ?? name,
+        required: def.required !== false
+      })),
+      input.contextMarkdown,
+      input.aiProvider
+    );
+    for (const [name, val] of Object.entries(extracted)) {
+      if (!values.has(name) && val) {
+        values.set(name, val);
+        contextExtractedKeys.add(name);
+      }
+    }
+  }
+  if (!input.skipEnv) {
+    for (const [name, def] of Object.entries(variables)) {
+      if (def.source === "env" && !values.has(name) && def.envKey) {
+        const envVal = process.env[def.envKey];
+        if (envVal !== void 0) {
+          values.set(name, envVal);
+        }
+      }
+    }
+  }
+  for (const [name, def] of Object.entries(variables)) {
+    if (def.source === "expression" && !values.has(name) && def.expression) {
+      const resolved = resolveTemplate(def.expression, values);
+      if (!/\{\{[\w.]+\}\}/.test(resolved)) {
+        values.set(name, resolved);
+      }
+    }
+  }
+  for (const [name, def] of Object.entries(variables)) {
+    if (!values.has(name) && !unresolvedDataVars.includes(name) && def.value !== void 0) {
+      values.set(name, def.value);
+    }
+  }
+  return {
+    values,
+    sensitiveKeys,
+    unresolvedDataVars,
+    captureVars,
+    contextExtractedKeys,
+    secretsKeys
+  };
+}
+async function planExecution(runbook, config) {
+  const variables = runbook.variables ?? {};
+  const hasContextVars = Object.entries(variables).some(
+    ([name]) => !config.secrets?.keys.has(name) && variables[name]?.source !== "data"
+  );
+  if (hasContextVars) {
+    log.step(t("planner.extractingFromContext"));
+  }
+  const coreResult = await resolveVariablesCore(runbook, {
+    secrets: config.secrets,
+    contextMarkdown: config.contextMarkdown,
+    skipEnv: false
+  });
+  if (hasContextVars) {
+    log.info(tf("planner.extractedFromContext", { count: coreResult.contextExtractedKeys.size }));
+  }
+  const captureVarNames = new Set(coreResult.captureVars);
+  const stillUnresolved = Object.entries(variables).filter(
+    ([name, def]) => !coreResult.values.has(name) && !coreResult.unresolvedDataVars.includes(name) && !captureVarNames.has(name) && def.required !== false
+  );
+  if (stillUnresolved.length > 0) {
+    log.warn(tf("planner.unresolvedRequired", { count: stillUnresolved.length }));
+    for (const [name, def] of stillUnresolved) {
+      const answer = await promptText(def.description ?? name, {
+        placeholder: t("planner.placeholder"),
+        validate: (v) => !v?.trim() ? tf("planner.variableRequired", { name }) : void 0
+      });
+      coreResult.values.set(name, answer.trim());
+    }
+  }
+  return {
+    resolvedVariables: {
+      values: coreResult.values,
+      sensitiveKeys: coreResult.sensitiveKeys
+    },
+    unresolvedDataVars: coreResult.unresolvedDataVars,
+    captureVars: coreResult.captureVars,
+    dataFilePath: config.dataFilePath,
+    contextExtractedKeys: coreResult.contextExtractedKeys,
+    secretsKeys: coreResult.secretsKeys
+  };
+}
+function displayPlan(plan, runbook, dataRowCount) {
+  const lines = [];
+  lines.push(t("planner.preVariables"));
+  if (plan.resolvedVariables.values.size === 0 && plan.unresolvedDataVars.length === 0) {
+    lines.push("  " + t("common.none"));
+  } else {
+    for (const [name, value] of plan.resolvedVariables.values) {
+      const display = plan.resolvedVariables.sensitiveKeys.has(name) ? `"${value.slice(0, 3)}****"` : `"${value}"`;
+      let source = "";
+      if (plan.secretsKeys.has(name)) {
+        source = t("planner.fromSecrets");
+      } else if (plan.contextExtractedKeys.has(name)) {
+        source = t("planner.fromContext");
+      }
+      lines.push(`  ${name} \u2192 ${display}${source}`);
+    }
+    for (const name of plan.unresolvedDataVars) {
+      lines.push(`  ${name} \u2192 ${t("planner.fromDataSource")}`);
+    }
+  }
+  if (plan.captureVars.length > 0) {
+    let displayCaptures2 = function(steps, prefix) {
+      for (const step of steps) {
+        if (step.captures) {
+          for (const c of step.captures) {
+            lines.push(`  ${c.name} \u2190 ${prefix}Step ${step.ordinal} (${c.strategy})`);
+          }
+        }
+        if (step.steps) {
+          displayCaptures2(step.steps, `${prefix}Loop ${step.ordinal} > `);
+        }
+        if (step.branches) {
+          for (const branchCase of step.branches.cases) {
+            displayCaptures2(branchCase.steps, `${prefix}Branch ${step.ordinal}/${branchCase.match} > `);
+          }
+          if (step.branches.default) {
+            displayCaptures2(step.branches.default.steps, `${prefix}Branch ${step.ordinal}/default > `);
+          }
+        }
+      }
+    };
+    var displayCaptures = displayCaptures2;
+    lines.push("");
+    lines.push(t("planner.runtimeCaptures"));
+    displayCaptures2(runbook.steps, "");
+  }
+  const conditionSteps = runbook.steps.filter((s) => s.condition);
+  const loopSteps = runbook.steps.filter((s) => s.loop && s.steps);
+  const branchSteps = runbook.steps.filter((s) => s.branches);
+  if (conditionSteps.length > 0 || loopSteps.length > 0 || branchSteps.length > 0) {
+    lines.push("");
+    lines.push(t("planner.controlFlow"));
+    for (const step of conditionSteps) {
+      lines.push(tf("planner.conditionLabel", { ordinal: step.ordinal, condition: step.condition ?? "" }));
+    }
+    for (const step of loopSteps) {
+      if (step.loop.forEach) {
+        const maxIter = step.loop.maxIterations ?? 100;
+        lines.push(
+          tf("planner.forEachLabel", { ordinal: step.ordinal, max: maxIter, subSteps: step.steps.length, forEach: step.loop.forEach })
+        );
+      } else {
+        const maxIter = step.loop.maxIterations ?? 10;
+        lines.push(
+          tf("planner.loopLabel", { ordinal: step.ordinal, max: maxIter, subSteps: step.steps.length, condition: step.loop.condition ?? "" })
+        );
+      }
+    }
+    for (const step of branchSteps) {
+      const caseLabels = step.branches.cases.map((c) => c.match).join(", ");
+      lines.push(
+        tf("planner.branchLabel", { ordinal: step.ordinal, value: step.branches.value, cases: caseLabels })
+      );
+    }
+  }
+  if (plan.dataFilePath && dataRowCount !== void 0) {
+    lines.push("");
+    lines.push(tf("planner.batchMode", { count: dataRowCount, path: plan.dataFilePath }));
+  }
+  lines.push(tf("planner.stepCount", { count: runbook.steps.length }));
+  note(lines.join("\n"), t("planner.executionPlan"));
+}
+async function confirmPlan() {
+  return promptConfirm(t("planner.confirmStart"), true);
+}
+
+// src/context/runtime-store.ts
+var MAX_RECENT_SUMMARIES = 5;
+var RuntimeStore = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+    this.sensitiveKeys = /* @__PURE__ */ new Set();
+    this.wm = {
+      currentPhase: "initial",
+      completedPhases: [],
+      recentStepSummaries: [],
+      currentPageContext: "",
+      successStreak: 0,
+      failureCount: 0,
+      totalSteps: 0,
+      lastUrl: "",
+      lastActionType: "",
+      actionTypeRun: 0
+    };
+  }
+  /** 事前解決済み変数をシードする */
+  seed(values, sensitive) {
+    for (const [k, v] of values) {
+      this.store.set(k, v);
+    }
+    for (const k of sensitive) {
+      this.sensitiveKeys.add(k);
+    }
+  }
+  get(name) {
+    return this.store.get(name);
+  }
+  set(name, value) {
+    this.store.set(name, value);
+  }
+  has(name) {
+    return this.store.has(name);
+  }
+  isSensitive(name) {
+    return this.sensitiveKeys.has(name);
+  }
+  /** sensitive として登録されたキー名一覧を返す */
+  getSensitiveKeys() {
+    return Array.from(this.sensitiveKeys);
+  }
+  /** store の値で {{varName}} を展開する */
+  resolveTemplate(template) {
+    return resolveTemplate(template, this.store);
+  }
+  /** ログ出力用: sensitive な値をマスクした文字列を返す */
+  maskSensitive(value) {
+    let masked = value;
+    for (const key of this.sensitiveKeys) {
+      const val = this.store.get(key);
+      if (val && masked.includes(val)) {
+        masked = masked.replaceAll(val, "****");
+      }
+    }
+    return masked;
+  }
+  /** 全変数のスナップショット（デバッグ用） */
+  entries() {
+    return Array.from(this.store.entries());
+  }
+  // ─────────────── forEach ヘルパー ───────────────
+  /**
+   * forEach ループの各アイテムを変数としてセットする。
+   * オブジェクト → varName = JSON文字列, varName.key = value にフラット化（1階層のみ）
+   * プリミティブ → varName = String(item)
+   */
+  setForEachItem(varName, item, indexVar, index) {
+    if (indexVar !== void 0 && index !== void 0) {
+      this.store.set(indexVar, String(index));
+    }
+    if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+      this.store.set(varName, JSON.stringify(item));
+      for (const [key, value] of Object.entries(item)) {
+        this.store.set(`${varName}.${key}`, String(value ?? ""));
+      }
+    } else {
+      this.store.set(varName, String(item ?? ""));
+    }
+  }
+  /**
+   * forEach ループのアイテム変数をクリーンアップする。
+   * varName と全 varName.* キーを削除。
+   */
+  clearForEachItem(varName, indexVar) {
+    this.store.delete(varName);
+    if (indexVar) {
+      this.store.delete(indexVar);
+    }
+    const prefix = `${varName}.`;
+    for (const key of Array.from(this.store.keys())) {
+      if (key.startsWith(prefix)) {
+        this.store.delete(key);
+      }
+    }
+  }
+  // ─────────────── Working Memory ───────────────
+  /**
+   * ステップ完了後に Working Memory を更新する。
+   * フェーズ自動検出 + ステップ履歴の記録。
+   */
+  updateWorkingMemory(stepOrdinal, totalStepCount, success, url, actionType, stepDescription) {
+    this.wm.totalSteps = totalStepCount;
+    if (success) {
+      this.wm.successStreak++;
+      this.wm.failureCount = 0;
+    } else {
+      this.wm.successStreak = 0;
+      this.wm.failureCount++;
+    }
+    const summary = `Step ${stepOrdinal}: ${stepDescription} \u2192 ${success ? "OK" : "FAIL"}`;
+    this.wm.recentStepSummaries.push(summary);
+    if (this.wm.recentStepSummaries.length > MAX_RECENT_SUMMARIES) {
+      this.wm.recentStepSummaries.shift();
+    }
+    this.wm.currentPageContext = url;
+    this.detectPhaseTransition(stepOrdinal, url, actionType);
+    this.wm.lastUrl = url;
+    this.wm.lastActionType = actionType;
+  }
+  /**
+   * AI プロンプト注入用の Working Memory サマリーを返す。
+   * 100〜200 トークンの簡潔な構造化テキスト。
+   * Working Memory がまだ蓄積されていない場合は undefined を返す。
+   */
+  getWorkingMemorySummary() {
+    if (this.wm.recentStepSummaries.length === 0) return void 0;
+    const parts = [];
+    if (this.wm.completedPhases.length > 0) {
+      const phaseHistory = this.wm.completedPhases.map((p) => `${p.name}(steps ${p.startStep}-${p.endStep ?? "?"})`).join(" \u2192 ");
+      parts.push(`Phases: ${phaseHistory} \u2192 ${this.wm.currentPhase}(current)`);
+    } else {
+      parts.push(`Phase: ${this.wm.currentPhase}`);
+    }
+    const recent = this.wm.recentStepSummaries.slice(-3).join("; ");
+    parts.push(`Recent: ${recent}`);
+    const statusParts = [];
+    if (this.wm.successStreak > 0) {
+      statusParts.push(`${this.wm.successStreak} consecutive successes`);
+    }
+    if (this.wm.failureCount > 0) {
+      statusParts.push(`${this.wm.failureCount} consecutive failures`);
+    }
+    if (statusParts.length > 0) {
+      parts.push(`Status: ${statusParts.join(", ")}`);
+    }
+    parts.push(`URL: ${this.wm.currentPageContext}`);
+    return parts.join("\n");
+  }
+  /**
+   * URL パターン変化 + アクションタイプのクラスタリングでフェーズ遷移を検出。
+   * AI 呼び出し不要のヒューリスティック。
+   */
+  detectPhaseTransition(stepOrdinal, url, actionType) {
+    const urlPath = extractUrlPath(url);
+    const lastUrlPath = extractUrlPath(this.wm.lastUrl);
+    const pathChanged = urlPath !== lastUrlPath && this.wm.lastUrl !== "";
+    if (actionType === this.wm.lastActionType) {
+      this.wm.actionTypeRun++;
+    } else {
+      this.wm.actionTypeRun = 1;
+    }
+    const newPhase = detectPhaseFromContext(urlPath, actionType, this.wm.actionTypeRun);
+    if (newPhase !== this.wm.currentPhase && (pathChanged || this.wm.actionTypeRun >= 3)) {
+      if (this.wm.currentPhase !== "initial") {
+        const lastPhase = this.wm.completedPhases[this.wm.completedPhases.length - 1];
+        const startStep = lastPhase ? (lastPhase.endStep ?? 0) + 1 : 1;
+        this.wm.completedPhases.push({
+          name: this.wm.currentPhase,
+          startStep,
+          endStep: stepOrdinal - 1,
+          summary: `${this.wm.currentPhase} completed`
+        });
+      }
+      this.wm.currentPhase = newPhase;
+    }
+  }
+};
+function extractUrlPath(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.pathname;
+  } catch {
+    return url;
+  }
+}
+function detectPhaseFromContext(urlPath, actionType, actionTypeRun) {
+  if (/\/(login|signin|auth)/i.test(urlPath)) return "authentication";
+  if (/\/(dashboard|home|overview)/i.test(urlPath)) return "navigation";
+  if (/\/(settings|config|preferences)/i.test(urlPath)) return "configuration";
+  if (actionType === "input" && actionTypeRun >= 2) return "form_filling";
+  if (actionType === "extract" && actionTypeRun >= 2) return "data_extraction";
+  if (actionType === "click" && actionTypeRun >= 3) return "navigation";
+  if (actionType === "download") return "data_export";
+  return "general";
+}
+
+// src/messaging/chat-bot.ts
+import { Chat } from "chat";
+import { createSlackAdapter } from "@chat-adapter/slack";
+import { createTeamsAdapter } from "@chat-adapter/teams";
+import { createDiscordAdapter } from "@chat-adapter/discord";
+import { createMemoryState } from "@chat-adapter/state-memory";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+var ADAPTER_NAME = {
+  slack: "slack",
+  teams: "teams",
+  discord: "discord"
+};
+var SharedChatBot = class {
+  constructor(config) {
+    this.bot = null;
+    this.server = null;
+    this.channel = null;
+    this.initialized = false;
+    this.config = config;
+  }
+  /**
+   * 遅延初期化: Chat SDK インスタンスと Hono webhook サーバーを起動。
+   * 複数回呼ばれても冪等。
+   */
+  async ensureInitialized() {
+    if (this.initialized) return;
+    this.initialized = true;
+    const adapter = this.createAdapter();
+    this.bot = new Chat({
+      userName: "refrain",
+      adapters: { [ADAPTER_NAME[this.config.platform]]: adapter },
+      state: createMemoryState(),
+      logger: "silent"
+    });
+    if (!this.config.skipWebhookServer) {
+      this.startWebhookServer();
+    }
+    await this.bot.initialize();
+  }
+  /**
+   * プロアクティブメッセージ用チャンネルを取得。
+   * chat.channel("slack:C12345") 形式で指定。
+   */
+  getChannel() {
+    if (!this.bot) throw new Error("SharedChatBot not initialized. Call ensureInitialized() first.");
+    if (!this.channel) {
+      const adapterName = ADAPTER_NAME[this.config.platform];
+      this.channel = this.bot.channel(`${adapterName}:${this.config.channelId}`);
+    }
+    return this.channel;
+  }
+  /**
+   * ボタンクリック（Action）ハンドラを登録。
+   * 承認カードのボタン ID に対応するハンドラを登録する。
+   */
+  onAction(actionIds, handler) {
+    if (!this.bot) throw new Error("SharedChatBot not initialized. Call ensureInitialized() first.");
+    this.bot.onAction(actionIds, (event) => handler({ actionId: event.actionId, value: event.value }));
+  }
+  /**
+   * Chat SDK + webhook サーバーをシャットダウン。
+   */
+  async dispose() {
+    if (this.bot) {
+      await this.bot.shutdown();
+      this.bot = null;
+    }
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    this.channel = null;
+    this.initialized = false;
+  }
+  createAdapter() {
+    const creds = this.config.credentials;
+    switch (this.config.platform) {
+      case "slack":
+        return creds ? createSlackAdapter({
+          botToken: creds.SLACK_BOT_TOKEN,
+          signingSecret: creds.SLACK_SIGNING_SECRET
+        }) : createSlackAdapter();
+      case "teams":
+        return creds ? createTeamsAdapter({
+          appId: creds.TEAMS_APP_ID,
+          appPassword: creds.TEAMS_APP_PASSWORD,
+          appTenantId: creds.TEAMS_APP_TENANT_ID
+        }) : createTeamsAdapter();
+      case "discord":
+        return creds ? createDiscordAdapter({
+          botToken: creds.DISCORD_BOT_TOKEN,
+          publicKey: creds.DISCORD_PUBLIC_KEY,
+          applicationId: creds.DISCORD_APPLICATION_ID
+        }) : createDiscordAdapter();
+    }
+  }
+  startWebhookServer() {
+    const app = new Hono();
+    const platform = this.config.platform;
+    app.post(`/webhooks/${platform}`, async (c) => {
+      if (!this.bot) return c.text("Bot not initialized", 500);
+      const webhookHandler = this.bot.webhooks[ADAPTER_NAME[platform]];
+      if (!webhookHandler) return c.text("Unknown platform", 400);
+      return webhookHandler(c.req.raw);
+    });
+    this.server = serve({ fetch: app.fetch, port: this.config.callbackPort });
+  }
+};
+
+// src/messaging/config.ts
+var DEFAULT_APPROVAL_TIMEOUT_MS = 3e5;
+var DEFAULT_CALLBACK_PORT = 3100;
+function loadChatConfig(platform, overrides) {
+  const channelId = loadChannelId(platform);
+  const callbackPort = overrides?.callbackPort ?? parseIntEnv("CHAT_CALLBACK_PORT") ?? parseIntEnv("SLACK_CALLBACK_PORT") ?? DEFAULT_CALLBACK_PORT;
+  const approvalTimeoutMs = overrides?.approvalTimeoutMs ?? parseIntEnv("CHAT_APPROVAL_TIMEOUT_MS") ?? parseIntEnv("SLACK_APPROVAL_TIMEOUT_MS") ?? DEFAULT_APPROVAL_TIMEOUT_MS;
+  return { platform, channelId, callbackPort, approvalTimeoutMs };
+}
+function loadChannelId(platform) {
+  const envMap = {
+    slack: "SLACK_CHANNEL_ID",
+    teams: "TEAMS_CHANNEL_ID",
+    discord: "DISCORD_CHANNEL_ID"
+  };
+  const envKey = envMap[platform];
+  const value = process.env[envKey];
+  if (!value) {
+    throw new Error(`${envKey} environment variable is required for ${platform} messaging`);
+  }
+  return value;
+}
+function parseIntEnv(key) {
+  const v = process.env[key];
+  if (!v) return void 0;
+  const n = Number.parseInt(v, 10);
+  return Number.isNaN(n) ? void 0 : n;
+}
+
+// src/runbook-executor/self-heal-analyzer.ts
+import { z as z6 } from "zod";
+var suggestionSchema = z6.array(
+  z6.object({
+    stepOrdinal: z6.number().describe("\u5931\u6557\u3057\u305F\u30B9\u30C6\u30C3\u30D7\u306E ordinal"),
+    stepDescription: z6.string().describe("\u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E"),
+    error: z6.string().describe("\u5931\u6557\u30A8\u30E9\u30FC\u306E\u8981\u7D04"),
+    runbookFix: z6.string().describe(
+      "\u624B\u9806\u66F8\uFF08YAML\uFF09\u3078\u306E\u4FEE\u6B63\u63D0\u6848: \u30BB\u30EC\u30AF\u30BF\u5909\u66F4\u3001\u30B9\u30C6\u30C3\u30D7\u8FFD\u52A0/\u524A\u9664\u3001\u30A2\u30AF\u30B7\u30E7\u30F3\u5024\u306E\u66F4\u65B0\u306A\u3069"
+    ),
+    contextFix: z6.string().describe(
+      "\u30B3\u30F3\u30C6\u30AD\u30B9\u30C8\uFF08markdown\uFF09\u3078\u306E\u4FEE\u6B63\u63D0\u6848: \u30DA\u30FC\u30B8\u69CB\u9020\u5909\u66F4\u306E\u8A18\u8F09\u3001\u524D\u63D0\u6761\u4EF6\u306E\u8FFD\u52A0\u306A\u3069\u3002context \u672A\u63D0\u4F9B\u6642\u306F\u7A7A\u6587\u5B57"
+    ),
+    severity: z6.enum(["error", "warning"]).describe("error: \u5B9F\u884C\u4E0D\u53EF\u3001warning: \u4E0D\u5B89\u5B9A"),
+    failureCategory: z6.enum([
+      "element_not_found",
+      "element_stale",
+      "page_structure_changed",
+      "navigation_timeout",
+      "action_failed",
+      "unknown"
+    ]).optional().describe("\u30A8\u30E9\u30FC\u5206\u985E\u30AB\u30C6\u30B4\u30EA"),
+    suggestedStrategy: z6.string().optional().describe("\u30AB\u30C6\u30B4\u30EA\u306B\u57FA\u3065\u304F\u63A8\u5968\u5BFE\u5FDC")
+  })
+);
+async function analyzeDebugResult(report, runbook, retryWarningThreshold, contextMarkdown, aiProvider) {
+  const warningSteps = extractWarningSteps(report, retryWarningThreshold);
+  const failedSteps = report.steps.filter((s) => s.status === "failed");
+  if (failedSteps.length === 0 && warningSteps.length === 0) {
+    return { executionReport: report, warningSteps: [], suggestions: [] };
+  }
+  const suggestions = await generateSuggestions(report, runbook, contextMarkdown, aiProvider);
+  return { executionReport: report, warningSteps, suggestions };
+}
+function extractWarningSteps(report, threshold) {
+  const warnings = [];
+  for (const step of report.steps) {
+    if (step.retryCount !== void 0 && step.retryCount >= threshold) {
+      warnings.push({
+        ordinal: step.ordinal,
+        description: step.description,
+        retryCount: step.retryCount,
+        threshold
+      });
+    }
+  }
+  return warnings;
+}
+async function generateSuggestions(report, runbook, contextMarkdown, aiProvider) {
+  const failedSteps = report.steps.filter((s) => s.status === "failed");
+  if (failedSteps.length === 0) return [];
+  const failedInfo = failedSteps.map((s) => {
+    const retryInfo = s.retryDetails ? s.retryDetails.map(
+      (d) => `  attempt ${d.attempt}: ${d.failureReason} (elements: ${d.snapshotElementCount}, changed: ${d.snapshotChanged}${d.aiReasoning ? `, AI: ${d.aiReasoning.slice(0, 100)}` : ""})`
+    ).join("\n") : "  \u30EA\u30C8\u30E9\u30A4\u8A73\u7D30\u306A\u3057";
+    const categoryInfo = s.failureCategory ? `
+  \u30A8\u30E9\u30FC\u5206\u985E: ${s.failureCategory}
+  \u63A8\u5968\u5BFE\u5FDC: ${getRecoveryHint(s.failureCategory)}` : "";
+    return `Step #${s.ordinal}: ${s.description}
+  \u30A8\u30E9\u30FC: ${s.error}
+  \u30EA\u30C8\u30E9\u30A4\u56DE\u6570: ${s.retryCount ?? 0}
+${retryInfo}${categoryInfo}`;
+  });
+  const stepsInfo = runbook.steps.map((s) => {
+    const selector = s.action.selector ? JSON.stringify(s.action.selector) : "\u306A\u3057";
+    const valuePart = s.action.value ? `
+  \u5024: ${s.action.value}` : "";
+    return `Step #${s.ordinal}: ${s.description}
+  \u30A2\u30AF\u30B7\u30E7\u30F3: ${s.action.type}${valuePart}
+  \u30BB\u30EC\u30AF\u30BF: ${selector}
+  URL: ${s.url}`;
+  });
+  const system = getSuggestionSystemPrompt();
+  const userPrompt = buildSuggestionUserPrompt(failedInfo, stepsInfo, runbook, contextMarkdown);
+  try {
+    const model = aiProvider ? aiProvider.getModel("review") : getModel("review");
+    const { object } = await trackedGenerateObject("review", {
+      model,
+      messages: [
+        {
+          role: "system",
+          content: system,
+          providerOptions: {
+            anthropic: { cacheControl: { type: "ephemeral" } }
+          }
+        },
+        { role: "user", content: userPrompt }
+      ],
+      schema: suggestionSchema,
+      temperature: 0.2
+    });
+    return object;
+  } catch {
+    return [];
+  }
+}
+
+// src/messaging/cards.ts
+import {
+  Card,
+  CardText,
+  Button,
+  Actions,
+  Section,
+  Fields,
+  Field,
+  Divider
+} from "chat";
+var ACTION_IDS = {
+  approve: "rfn-approve",
+  skip: "rfn-skip",
+  abort: "rfn-abort"
+};
+var RISK_EMOJI = {
+  low: "\u{1F7E2}",
+  // green circle
+  medium: "\u26A0\uFE0F",
+  // warning
+  high: "\u{1F534}"
+  // red circle
+};
+function buildApprovalCard(step, context, metadata) {
+  const riskEmoji = RISK_EMOJI[step.riskLevel] ?? "";
+  const goalLine = context?.goal ? `${t("chat.taskLabel")}${context.goal}
+` : "";
+  const buttonId = (actionId) => metadata ? `${actionId}:${metadata.jobId}:${metadata.stepOrdinal}` : actionId;
+  const buttonValue = metadata ? `${metadata.jobId}:${metadata.stepOrdinal}` : void 0;
+  return Card({
+    title: t("chat.approvalRequest"),
+    children: [
+      Section([
+        CardText(
+          tf("chat.approvalDescription", {
+            goalLine,
+            description: step.description,
+            riskEmoji,
+            riskLevel: step.riskLevel
+          })
+        )
+      ]),
+      Actions([
+        Button({ id: buttonId(ACTION_IDS.approve), label: t("chat.approveButton"), style: "primary", value: buttonValue }),
+        Button({ id: buttonId(ACTION_IDS.skip), label: t("chat.skipButton"), value: buttonValue }),
+        Button({ id: buttonId(ACTION_IDS.abort), label: t("chat.abortButton"), style: "danger", value: buttonValue })
+      ])
+    ]
+  });
+}
+function buildApprovalResultCard(step, resultText) {
+  return Card({
+    children: [
+      Section([
+        CardText(`*${t("chat.stepPrefix")} ${step.ordinal}* ${step.description}
+${resultText}`)
+      ])
+    ]
+  });
+}
+function statusEmoji(report) {
+  if ("totalRows" in report) {
+    const b = report;
+    if (b.failed === 0) return "\u2705";
+    if (b.succeeded === 0) return "\u274C";
+    return "\u26A0\uFE0F";
+  }
+  const r = report;
+  if (r.aborted) return "\u{1F6D1}";
+  if (r.failed === 0) return "\u2705";
+  if (r.succeeded === 0) return "\u274C";
+  return "\u26A0\uFE0F";
+}
+function buildNotificationCard(report) {
+  const isBatch = "totalRows" in report;
+  return isBatch ? buildBatchCard(report) : buildSingleCard(report);
+}
+function buildSingleCard(report) {
+  const emoji = statusEmoji(report);
+  const abortTag = report.aborted ? `  \u{1F6D1} ${t("chat.abortTag")}` : "";
+  const children = [
+    Section([
+      CardText(`*${emoji} ${report.runbookTitle}*`)
+    ]),
+    Fields([
+      Field({ label: t("chat.succeededFieldLabel"), value: `\u2705 ${report.succeeded}` }),
+      Field({ label: t("chat.failedFieldLabel"), value: `\u274C ${report.failed}` }),
+      Field({ label: t("chat.skippedFieldLabel"), value: `\u23E9 ${report.skipped}` }),
+      Field({ label: t("chat.durationFieldLabel"), value: `\u23F1 ${formatDuration(report.totalDurationMs)}${abortTag}` })
+    ])
+  ];
+  const failedSteps = report.steps.filter((s) => s.status === "failed");
+  if (failedSteps.length > 0) {
+    children.push(Divider());
+    children.push(
+      Section([
+        CardText(`*${t("chat.failedLabel")}*
+${formatFailedSteps(failedSteps)}`)
+      ])
+    );
+  }
+  return Card({ children });
+}
+function buildBatchCard(report) {
+  const emoji = statusEmoji(report);
+  const children = [
+    Section([
+      CardText(`*${emoji} ${report.runbookTitle} (${t("chat.batchTag")})*`)
+    ]),
+    Fields([
+      Field({ label: t("chat.totalFieldLabel"), value: tf("chat.totalRows", { count: report.totalRows }) }),
+      Field({ label: t("chat.succeededFieldLabel"), value: `\u2705 ${report.succeeded}` }),
+      Field({ label: t("chat.failedFieldLabel"), value: `\u274C ${report.failed}` }),
+      Field({ label: t("chat.durationFieldLabel"), value: `\u23F1 ${formatDuration(report.totalDurationMs)}` })
+    ])
+  ];
+  const failedRows = report.rows.filter((r) => r.report.failed > 0 || r.report.aborted);
+  if (failedRows.length > 0) {
+    const rowLines = failedRows.slice(0, 10).map((row) => {
+      const failed = row.report.steps.filter((s) => s.status === "failed");
+      const stepInfo = failed.map((s) => `#${s.ordinal}`).join(", ");
+      return `- ${row.rowLabel}: ${stepInfo}`;
+    });
+    if (failedRows.length > 10) {
+      rowLines.push(tf("chat.moreRows", { count: failedRows.length - 10 }));
+    }
+    children.push(Divider());
+    children.push(
+      Section([
+        CardText(`*${t("chat.failedRows")}*
+${rowLines.join("\n")}`)
+      ])
+    );
+  }
+  return Card({ children });
+}
+function buildDebugNotificationCard(report) {
+  const r = report.executionReport;
+  const children = [
+    Section([
+      CardText(`*\u{1F50D} ${tf("chat.debugFailure", { title: r.runbookTitle })}*`)
+    ]),
+    Fields([
+      Field({ label: t("chat.succeededFieldLabel"), value: `\u2705 ${r.succeeded}` }),
+      Field({ label: t("chat.failedFieldLabel"), value: `\u274C ${r.failed}` }),
+      Field({ label: t("chat.skippedFieldLabel"), value: `\u23E9 ${r.skipped}` }),
+      Field({ label: t("chat.durationFieldLabel"), value: `\u23F1 ${formatDuration(r.totalDurationMs)}` })
+    ])
+  ];
+  const failedSteps = r.steps.filter((s) => s.status === "failed");
+  if (failedSteps.length > 0) {
+    children.push(Divider());
+    children.push(
+      Section([
+        CardText(`*${t("chat.failedLabel")}*
+${formatFailedSteps(failedSteps, { limit: 15, errorMaxLen: 80, showRetries: true })}`)
+      ])
+    );
+  }
+  const allSuggestionLines = [];
+  const runbookSuggestions = report.suggestions.filter((s) => s.runbookFix);
+  for (const s of runbookSuggestions.slice(0, 10)) {
+    const prefix = s.severity === "error" ? "\u274C" : "\u26A0\uFE0F";
+    allSuggestionLines.push(`${prefix} #${s.stepOrdinal} [YAML]: ${s.runbookFix.slice(0, 100)}`);
+  }
+  const contextSuggestions = report.suggestions.filter((s) => s.contextFix);
+  for (const s of contextSuggestions.slice(0, 10)) {
+    const prefix = s.severity === "error" ? "\u274C" : "\u26A0\uFE0F";
+    allSuggestionLines.push(`${prefix} #${s.stepOrdinal} [ctx]: ${s.contextFix.slice(0, 100)}`);
+  }
+  const totalSuggestions = runbookSuggestions.length + contextSuggestions.length;
+  if (allSuggestionLines.length > 0 && totalSuggestions > allSuggestionLines.length) {
+    allSuggestionLines.push(tf("chat.moreItems", { count: totalSuggestions - allSuggestionLines.length }));
+  }
+  if (allSuggestionLines.length > 0) {
+    children.push(Divider());
+    children.push(
+      Section([
+        CardText(`*${t("chat.suggestionsLabel")}*
+${allSuggestionLines.join("\n")}`)
+      ])
+    );
+  }
+  if (report.warningSteps.length > 0) {
+    const lines = report.warningSteps.slice(0, 10).map(
+      (w) => `- #${w.ordinal} ${w.description}: retry ${w.retryCount}/${w.threshold}`
+    );
+    if (report.warningSteps.length > 10) {
+      lines.push(tf("chat.moreItems", { count: report.warningSteps.length - 10 }));
+    }
+    children.push(Divider());
+    children.push(
+      Section([
+        CardText(`*${t("chat.retryWarningsLabel")}*
+${lines.join("\n")}`)
+      ])
+    );
+  }
+  return Card({ children });
+}
+function buildGenerateNotificationCard(info) {
+  const emoji = info.goalAchieved ? "\u2705" : "\u274C";
+  return Card({
+    children: [
+      Section([
+        CardText(`*${emoji} ${t("chat.generateComplete")}*`)
+      ]),
+      Fields([
+        Field({ label: t("chat.goalFieldLabel"), value: info.goal }),
+        Field({ label: t("chat.goalAchievedFieldLabel"), value: info.goalAchieved ? "\u2705" : "\u274C" }),
+        Field({ label: t("chat.stepsFieldLabel"), value: String(info.stepsCount) }),
+        Field({ label: t("chat.yamlFieldLabel"), value: info.yamlGenerated ? "\u2705" : "\u274C" })
+      ])
+    ]
+  });
+}
+function formatFailedSteps(steps, options) {
+  const { limit = 10, errorMaxLen = 100, showRetries = false } = options ?? {};
+  const lines = steps.slice(0, limit).map((s) => {
+    const errMsg = s.error ? `: ${s.error.slice(0, errorMaxLen)}` : "";
+    const retries = showRetries && s.retryCount ? ` (retry:${s.retryCount})` : "";
+    const categoryTag = s.failureCategory ? ` [${s.failureCategory}]` : "";
+    return `- #${s.ordinal} ${s.description}${errMsg}${retries}${categoryTag}`;
+  });
+  if (steps.length > limit) {
+    lines.push(tf("chat.moreSteps", { count: steps.length - limit }));
+  }
+  return lines.join("\n");
+}
+
+export {
+  SELF_HEAL_DEFAULTS,
+  applyExecutorDefaults,
+  detectKeyKind,
+  generateDebugToken,
+  getDebugSigningKey,
+  getDebugPublicKey,
+  COMMUNITY_PLAN,
+  PLAN_PRICING,
+  TIER_TO_PLAN,
+  resolvePlanFromTier,
+  resolvePlan,
+  getApiKey,
+  enforceFeatureGates,
+  validateStepLimit,
+  validateBatchLimit,
+  formatPlanLabel,
+  normalizeUrlPattern,
+  buildSelectorHint,
+  loadCache,
+  saveCache,
+  CliConfirmationProvider,
+  execute,
+  mergeVariablesAndSecrets,
+  resolveVariablesCore,
+  planExecution,
+  displayPlan,
+  confirmPlan,
+  RuntimeStore,
+  SharedChatBot,
+  DEFAULT_APPROVAL_TIMEOUT_MS,
+  DEFAULT_CALLBACK_PORT,
+  loadChatConfig,
+  ACTION_IDS,
+  buildApprovalCard,
+  buildApprovalResultCard,
+  buildNotificationCard,
+  buildDebugNotificationCard,
+  buildGenerateNotificationCard,
+  analyzeDebugResult
+};
+//# sourceMappingURL=chunk-H47NWH7N.js.map