@refrainai/cli 0.4.1

package/dist/runbook-executor-K7T6RJWJ.js

@@ -0,0 +1,1480 @@
+#!/usr/bin/env node
+import {
+  ACTION_IDS,
+  CliConfirmationProvider,
+  DEFAULT_APPROVAL_TIMEOUT_MS,
+  RuntimeStore,
+  SELF_HEAL_DEFAULTS,
+  SharedChatBot,
+  analyzeDebugResult,
+  applyExecutorDefaults,
+  buildApprovalCard,
+  buildApprovalResultCard,
+  buildDebugNotificationCard,
+  buildNotificationCard,
+  confirmPlan,
+  displayPlan,
+  enforceFeatureGates,
+  execute,
+  formatPlanLabel,
+  getApiKey,
+  loadCache,
+  loadChatConfig,
+  planExecution,
+  resolvePlan,
+  saveCache,
+  validateBatchLimit,
+  validateStepLimit
+} from "./chunk-H47NWH7N.js";
+import {
+  formatAiMetricsSection,
+  formatAiSelectorQualityIssues,
+  formatDebugLogSections,
+  formatFailureCategoryDistribution,
+  formatPerformanceBottlenecks,
+  formatRecoveryEffectiveness,
+  formatRetryDistribution,
+  formatRuntimeEnvironment,
+  formatSelectorResolutionStats,
+  readDebugLog,
+  renderOptionsMarkdown,
+  serializeExecutorOptions
+} from "./chunk-VPK2MQAZ.js";
+import {
+  checkHelpFlag,
+  getRawArgs,
+  parseModelConfig,
+  readContextFile,
+  validateNotifyMode
+} from "./chunk-2BVDAJZT.js";
+import {
+  AgentBrowser,
+  DownloadManager,
+  InMemoryDataStore,
+  NoopLogger,
+  NoopSpinner,
+  formatDuration,
+  getRecoveryHint,
+  loadSecrets
+} from "./chunk-DJVUITRB.js";
+import "./chunk-XMFCXPYU.js";
+import {
+  createSkills,
+  initBuiltinSkills
+} from "./chunk-AG3CFMYU.js";
+import "./chunk-D5SI2PHK.js";
+import {
+  cancel,
+  initLocale,
+  intro,
+  log,
+  note,
+  outro,
+  t,
+  tf
+} from "./chunk-7UCVPKD4.js";
+import {
+  computeCacheRate,
+  computeTotalRealInput,
+  globalMetrics,
+  initModel
+} from "./chunk-UGPXCQY3.js";
+import {
+  ParsedRunbookSchema
+} from "./chunk-RT664YIO.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/runbook-executor/config.ts
+import { parseArgs as nodeParseArgs } from "util";
+async function parseArgs() {
+  checkHelpFlag("execute");
+  const args = getRawArgs();
+  const { values } = nodeParseArgs({
+    args,
+    options: {
+      runbook: { type: "string" },
+      context: { type: "string" },
+      headless: { type: "string" },
+      "step-delay": { type: "string" },
+      screenshots: { type: "string" },
+      "skip-confirmation": { type: "boolean" },
+      data: { type: "string" },
+      secrets: { type: "string" },
+      "reuse-session": { type: "boolean" },
+      "no-reuse-session": { type: "boolean" },
+      "debug-log": { type: "string" },
+      debug: { type: "boolean" },
+      "approval-mode": { type: "string" },
+      notify: { type: "string" },
+      "enable-selector-cache": { type: "boolean" },
+      "enable-agent-fallback": { type: "boolean" },
+      "enable-vision-fallback": { type: "boolean" },
+      "output-dir": { type: "string" },
+      "merge-downloads": { type: "boolean" },
+      "self-heal": { type: "boolean" },
+      "max-retries": { type: "string" },
+      "retry-warning-threshold": { type: "string" },
+      report: { type: "boolean" },
+      model: { type: "string" },
+      "model-provider": { type: "string" },
+      "model-base-url": { type: "string" },
+      "model-selector": { type: "string" },
+      "model-extraction": { type: "string" },
+      "model-review": { type: "string" },
+      "model-fallback": { type: "string" },
+      "model-vision": { type: "string" },
+      "api-key": { type: "string" },
+      "api-server-url": { type: "string" },
+      "refresh-key": { type: "boolean" },
+      "callback-port": { type: "string" },
+      "approval-timeout": { type: "string" },
+      video: { type: "string" },
+      locale: { type: "string" },
+      stealth: { type: "boolean" },
+      proxy: { type: "string" },
+      skill: { type: "string" }
+    },
+    strict: true
+  });
+  initLocale(values.locale);
+  if (!values.runbook) {
+    cancel(t("cli.runbookRequired"));
+    process.exit(1);
+  }
+  if (!values.context) {
+    cancel(t("cli.contextRequired"));
+    process.exit(1);
+  }
+  const contextMarkdown = await readContextFile(values.context);
+  const secrets = await loadSecrets(values.secrets);
+  const aiModelConfig = parseModelConfig(values);
+  const reuseSession = values["no-reuse-session"] ? false : values["reuse-session"] ?? true;
+  const rawApprovalMode = values["approval-mode"];
+  const validApprovalModes = ["web", "slack", "teams", "discord"];
+  let approvalMode;
+  if (rawApprovalMode) {
+    if (!validApprovalModes.includes(rawApprovalMode)) {
+      cancel(t("cli.invalidApprovalMode"));
+      process.exit(1);
+    }
+    approvalMode = rawApprovalMode;
+  }
+  const notifyMode = validateNotifyMode(values.notify);
+  if (approvalMode && approvalMode !== "web" && notifyMode && approvalMode !== notifyMode) {
+    cancel("--approval-mode and --notify must use the same platform");
+    process.exit(1);
+  }
+  const selfHeal = values["self-heal"] ?? false;
+  return {
+    runbookPath: values.runbook,
+    headless: values.headless !== "false",
+    stepDelay: values["step-delay"] ? Number.parseInt(values["step-delay"], 10) : void 0,
+    screenshotDir: values.screenshots,
+    contextMarkdown,
+    skipConfirmation: values["skip-confirmation"] ?? selfHeal,
+    dataFilePath: values.data,
+    secrets,
+    reuseSession,
+    debugLogPath: values["debug-log"],
+    debugConsole: values.debug ?? false,
+    approvalMode,
+    notifyMode,
+    callbackPort: values["callback-port"] ? Number.parseInt(values["callback-port"], 10) : void 0,
+    approvalTimeoutMs: values["approval-timeout"] ? Number.parseInt(values["approval-timeout"], 10) : void 0,
+    enableSelectorCache: values["enable-selector-cache"] ?? (selfHeal ? SELF_HEAL_DEFAULTS.enableSelectorCache : void 0),
+    enableAgentFallback: values["enable-agent-fallback"] ?? (selfHeal ? SELF_HEAL_DEFAULTS.enableAgentFallback : void 0),
+    enableVisionFallback: values["enable-vision-fallback"] ?? (selfHeal ? SELF_HEAL_DEFAULTS.enableVisionFallback : void 0),
+    outputDir: values["output-dir"],
+    mergeDownloads: values["merge-downloads"] ?? false,
+    selfHeal,
+    maxRetries: values["max-retries"] ? Number.parseInt(values["max-retries"], 10) : selfHeal ? SELF_HEAL_DEFAULTS.maxRetries : void 0,
+    retryWarningThreshold: values["retry-warning-threshold"] ? Number.parseInt(values["retry-warning-threshold"], 10) : selfHeal ? SELF_HEAL_DEFAULTS.retryWarningThreshold : void 0,
+    forceReport: values.report ?? false,
+    videoDir: values.video,
+    aiModelConfig,
+    apiKey: values["api-key"],
+    apiServerUrl: values["api-server-url"],
+    refreshKey: values["refresh-key"] ?? false,
+    stealth: values.stealth ?? false,
+    proxy: values.proxy,
+    skills: values.skill?.split(",").map((s) => s.trim()).filter(Boolean)
+  };
+}
+
+// src/runbook-executor/yaml-loader.ts
+import { readFile } from "fs/promises";
+import { parse } from "yaml";
+async function loadAndLogRunbook(path) {
+  const loadStart = performance.now();
+  const runbook = await loadRunbook(path);
+  log.info(`Title: ${runbook.title}`);
+  log.info(`Start URL: ${runbook.metadata.startUrl}`);
+  log.info(`Steps: ${runbook.steps.length}`);
+  log.info(`YAML loaded (${formatDuration(performance.now() - loadStart)})`);
+  return runbook;
+}
+async function loadRunbook(path) {
+  const raw = await readFile(path, "utf-8");
+  const doc = parse(raw);
+  return ParsedRunbookSchema.parse(doc);
+}
+
+// src/runbook-executor/reporter.ts
+function flattenSteps(steps) {
+  const result = [];
+  for (const step of steps) {
+    result.push(step);
+    if (step.subStepResults) {
+      for (const iteration of step.subStepResults) {
+        result.push(...flattenSteps(iteration));
+      }
+    }
+  }
+  return result;
+}
+function printStepResult(step, indent) {
+  const duration = formatDuration(step.durationMs);
+  if (step.conditionSkipped) {
+    log.warn(`${indent}#${step.ordinal} ${step.description} (${t("common.conditionSkipped")})`);
+    return;
+  }
+  if (step.branchMatch !== void 0) {
+    const matchLabel = step.branchMatch || t("common.skipped").toLowerCase();
+    const msg2 = `${indent}#${step.ordinal} ${step.description} (branch: ${matchLabel}, ${duration})`;
+    if (step.status === "success") {
+      log.success(msg2);
+    } else if (step.status === "skipped") {
+      log.warn(msg2);
+    } else {
+      log.error(msg2);
+    }
+    if (step.subStepResults) {
+      for (const subResults of step.subStepResults) {
+        for (const subResult of subResults) {
+          printStepResult(subResult, `${indent}  `);
+        }
+      }
+    }
+    return;
+  }
+  if (step.loopIterations !== void 0) {
+    const iterLabel = step.forEachItemCount !== void 0 ? `forEach: ${step.forEachItemCount} ${t("common.items")}` : `${step.loopIterations} ${t("common.iterations")}`;
+    const msg2 = `${indent}#${step.ordinal} ${step.description} (${iterLabel}, ${duration})`;
+    if (step.status === "success") {
+      log.success(msg2);
+    } else {
+      log.error(msg2);
+    }
+    if (step.subStepResults) {
+      for (let i = 0; i < step.subStepResults.length; i++) {
+        log.info(`${indent}  ${t("common.iteration")} ${i}:`);
+        for (const subResult of step.subStepResults[i]) {
+          printStepResult(subResult, `${indent}    `);
+        }
+      }
+    }
+    return;
+  }
+  const msg = `${indent}#${step.ordinal} ${step.description} (${duration})`;
+  if (step.status === "success") {
+    log.success(msg);
+    if (step.capturedValues) {
+      for (const [name, value] of Object.entries(step.capturedValues)) {
+        log.info(`${indent}  captured: ${name} = "${value}"`);
+      }
+    }
+    if (step.extractedData) {
+      const preview = step.extractedData.length > 80 ? `${step.extractedData.slice(0, 80)}...` : step.extractedData;
+      log.info(`${indent}  extracted: ${preview}`);
+    }
+    if (step.downloadedFile) {
+      log.info(`${indent}  downloaded: ${step.downloadedFile}`);
+    }
+    if (step.exportedFile) {
+      log.info(`${indent}  exported: ${step.exportedFile}`);
+    }
+  } else if (step.status === "failed") {
+    log.error(`${msg} ERROR: ${step.error}`);
+  } else {
+    log.warn(`${msg} (${t("common.skipped").toLowerCase()})`);
+  }
+}
+function printReport(report) {
+  const summaryLines = [
+    tf("reporter.runbook", { title: report.runbookTitle }),
+    tf("reporter.startUrl", { url: report.startUrl }),
+    tf("reporter.totalSteps", { count: report.totalSteps }),
+    tf("reporter.statsLine", { executed: report.executed, succeeded: report.succeeded, failed: report.failed, skipped: report.skipped }),
+    ...report.aborted ? [t("reporter.statusAborted")] : [],
+    tf("reporter.totalDuration", { duration: formatDuration(report.totalDurationMs) })
+  ];
+  if (report.memoryCollections && Object.keys(report.memoryCollections).length > 0) {
+    const memoryInfo = Object.entries(report.memoryCollections).map(([name, count]) => `${name}(${count}${t("common.items")})`).join(", ");
+    summaryLines.push(tf("reporter.memory", { info: memoryInfo }));
+  }
+  if (report.downloadedFiles && report.downloadedFiles.length > 0) {
+    summaryLines.push(tf("reporter.downloads", { count: report.downloadedFiles.length }));
+  }
+  if (report.aiMetrics && report.aiMetrics.totalCalls > 0) {
+    const m = report.aiMetrics;
+    const totalRealInput = computeTotalRealInput(m);
+    const cacheRate = (computeCacheRate(m) * 100).toFixed(1);
+    const purposeSummary = Object.entries(m.byPurpose).map(([p2, b]) => `${p2}(${b.calls})`).join(" ");
+    summaryLines.push(
+      `AI: ${m.totalCalls} calls, ${totalRealInput.toLocaleString()} in / ${m.totalOutputTokens.toLocaleString()} out, cache ${cacheRate}%, $${m.estimatedCostUsd.toFixed(4)}, ${(m.totalDurationMs / 1e3).toFixed(1)}s \u2014 ${purposeSummary}`
+    );
+    if (m.byModel && Object.keys(m.byModel).length > 1) {
+      const modelSummary = Object.entries(m.byModel).map(([id, b]) => `${id}($${b.estimatedCostUsd.toFixed(4)})`).join(" ");
+      summaryLines.push(`Models: ${modelSummary}`);
+    }
+  }
+  note(summaryLines.join("\n"), t("reporter.executionResult"));
+  const allFlatSteps = flattenSteps(report.steps);
+  const extractFailures = allFlatSteps.filter(
+    (s) => s.actionType === "extract" && s.status === "failed"
+  );
+  const extractEmpty = allFlatSteps.filter(
+    (s) => s.actionType === "extract" && s.status === "success" && (!s.extractedData || s.extractedData === "")
+  );
+  if (extractFailures.length > 0) {
+    log.error(`Extract failures: ${extractFailures.length} step(s) failed \u2014 ${extractFailures.map((s) => `#${s.ordinal}`).join(", ")}`);
+  }
+  if (extractEmpty.length > 0) {
+    log.warn(`Extract warnings: ${extractEmpty.length} step(s) returned empty results`);
+  }
+  for (const step of report.steps) {
+    printStepResult(step, "");
+  }
+}
+function printBatchReport(report) {
+  const summaryLines = [
+    tf("reporter.runbook", { title: report.runbookTitle }),
+    tf("reporter.batchTotalRows", { count: report.totalRows }),
+    tf("reporter.batchStats", { succeeded: report.succeeded, failed: report.failed }),
+    tf("reporter.totalDuration", { duration: formatDuration(report.totalDurationMs) })
+  ];
+  note(summaryLines.join("\n"), t("reporter.batchResult"));
+  for (const row of report.rows) {
+    const r = row.report;
+    const status = r.failed === 0 && !r.aborted ? "OK" : "NG";
+    const duration = formatDuration(r.totalDurationMs);
+    const msg = `${row.rowLabel}: ${status} (${r.succeeded}/${r.totalSteps} steps, ${duration})`;
+    if (status === "OK") {
+      log.success(msg);
+    } else {
+      log.error(msg);
+      for (const step of r.steps) {
+        if (step.status === "failed") {
+          log.error(`  #${step.ordinal} ${step.description}: ${step.error}`);
+        }
+      }
+    }
+  }
+}
+
+// src/runbook-executor/batch-runner.ts
+import { readFile as readFile2 } from "fs/promises";
+import { extname } from "path";
+async function loadDataFile(path) {
+  const raw = await readFile2(path, "utf-8");
+  const ext = extname(path).toLowerCase();
+  if (ext === ".json") {
+    const data = JSON.parse(raw);
+    if (!Array.isArray(data)) {
+      throw new Error("JSON data file must be an array of objects");
+    }
+    return data.map((row) => {
+      const result = {};
+      for (const [k, v] of Object.entries(row)) {
+        result[k] = String(v ?? "");
+      }
+      return result;
+    });
+  }
+  return parseCSV(raw);
+}
+function parseCSV(raw) {
+  const lines = raw.split("\n").filter((line) => line.trim() !== "");
+  if (lines.length < 2) return [];
+  const headers = parseCSVLine(lines[0]);
+  const rows = [];
+  for (let i = 1; i < lines.length; i++) {
+    const values = parseCSVLine(lines[i]);
+    const row = {};
+    for (let j = 0; j < headers.length; j++) {
+      row[headers[j]] = values[j] ?? "";
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+function parseCSVLine(line) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (inQuotes) {
+      if (char === '"') {
+        if (i + 1 < line.length && line[i + 1] === '"') {
+          current += '"';
+          i++;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        current += char;
+      }
+    } else {
+      if (char === '"') {
+        inQuotes = true;
+      } else if (char === ",") {
+        result.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+async function executeBatch(config, runbook, baseStore, dataRows, reuseSession, batchOpts = {}) {
+  const totalStart = performance.now();
+  const logger = batchOpts.logger ?? new NoopLogger();
+  const createSpinner = batchOpts.createSpinner ?? (() => new NoopSpinner());
+  const mapping = runbook.dataSource?.mapping ?? {};
+  const reverseMapping = /* @__PURE__ */ new Map();
+  for (const [varName, csvHeader] of Object.entries(mapping)) {
+    reverseMapping.set(csvHeader, varName);
+  }
+  const rowReports = [];
+  let succeeded = 0;
+  let failed = 0;
+  let sharedBrowser;
+  if (reuseSession) {
+    sharedBrowser = new AgentBrowser();
+    const s = createSpinner();
+    s.start("\u30D0\u30C3\u30C1\u7528\u30D6\u30E9\u30A6\u30B6\u3092\u8D77\u52D5\u4E2D...");
+    await sharedBrowser.open(runbook.metadata.startUrl, {
+      headless: config.headless,
+      stealth: config.stealth,
+      proxy: config.proxy
+    });
+    await new Promise((r) => setTimeout(r, 1e3));
+    s.stop(t("executor.batchBrowserReady"));
+  }
+  try {
+    for (let i = 0; i < dataRows.length; i++) {
+      const row = dataRows[i];
+      const rowLabel = `Row ${i + 1}/${dataRows.length}`;
+      logger.info(`
+\u2500\u2500 ${rowLabel} \u2500\u2500`);
+      if (reuseSession && sharedBrowser && config.videoDir) {
+        if (sharedBrowser.isRecording()) {
+          try {
+            await sharedBrowser.stopRecording();
+          } catch {
+          }
+        }
+        try {
+          await sharedBrowser.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) }));
+        }
+      }
+      const rowStore = new RuntimeStore();
+      const baseEntries = baseStore.entries();
+      const baseValues = new Map(baseEntries);
+      const sensitiveKeys = /* @__PURE__ */ new Set();
+      for (const [key] of baseEntries) {
+        if (baseStore.isSensitive(key)) {
+          sensitiveKeys.add(key);
+        }
+      }
+      for (const [csvHeader, value] of Object.entries(row)) {
+        const varName = reverseMapping.get(csvHeader);
+        if (varName) {
+          baseValues.set(varName, value);
+        }
+      }
+      rowStore.seed(baseValues, sensitiveKeys);
+      if (reuseSession && sharedBrowser && i > 0) {
+        const startUrl = rowStore.resolveTemplate(runbook.metadata.startUrl);
+        await sharedBrowser.navigate(startUrl);
+        await new Promise((r) => setTimeout(r, 500));
+      }
+      const rowConfig = config;
+      const report = await execute(rowConfig, runbook, {
+        store: rowStore,
+        browser: sharedBrowser,
+        confirmationProvider: batchOpts.confirmationProvider,
+        selectorCache: batchOpts.selectorCache,
+        logger,
+        createSpinner,
+        abortSignal: batchOpts.abortSignal,
+        skills: batchOpts.skills
+      });
+      rowReports.push({ rowIndex: i, rowLabel, report });
+      if (report.failed === 0 && !report.aborted) {
+        succeeded++;
+      } else {
+        failed++;
+      }
+    }
+  } finally {
+    if (sharedBrowser) {
+      if (sharedBrowser.isRecording()) {
+        try {
+          await sharedBrowser.stopRecording();
+        } catch {
+        }
+      }
+      try {
+        await sharedBrowser.close();
+      } catch {
+      }
+    }
+  }
+  return {
+    runbookTitle: runbook.title,
+    totalRows: dataRows.length,
+    succeeded,
+    failed,
+    rows: rowReports,
+    totalDurationMs: Math.round(performance.now() - totalStart)
+  };
+}
+
+// src/approval/chat-provider.ts
+var RESULT_LABELS = {
+  approve: "\u2705",
+  // check mark
+  skip: "\u23E9",
+  // fast forward
+  abort: "\u{1F6D1}"
+  // stop sign
+};
+var ChatConfirmationProvider = class {
+  constructor(sharedBot, timeoutMs) {
+    this.actionsRegistered = false;
+    this.pendingResolve = null;
+    this.sharedBot = sharedBot;
+    this.timeoutMs = timeoutMs;
+  }
+  async confirm(step, _stepIndex, context) {
+    await this.sharedBot.ensureInitialized();
+    this.registerActionsOnce();
+    const channel = this.sharedBot.getChannel();
+    const card = buildApprovalCard(step, context);
+    const sentMessage = await channel.post(card);
+    console.log(`[Chat] Step ${step.ordinal}: ${t("chat.approvalWaiting")}`);
+    return new Promise((resolve) => {
+      this.pendingResolve = resolve;
+      const timer = setTimeout(async () => {
+        if (this.pendingResolve === resolve) {
+          this.pendingResolve = null;
+          console.log(`[Chat] Step ${step.ordinal}: ${t("chat.approvalTimeout")}`);
+          try {
+            await sentMessage.edit(buildApprovalResultCard(step, t("chat.approvalTimeout")));
+          } catch {
+          }
+          resolve("abort");
+        }
+      }, this.timeoutMs);
+      const originalResolve = resolve;
+      this.pendingResolve = (result) => {
+        clearTimeout(timer);
+        this.pendingResolve = null;
+        console.log(`[Chat] Step ${step.ordinal}: ${result}`);
+        const resultLabel = getResultLabel(result);
+        sentMessage.edit(buildApprovalResultCard(step, resultLabel)).catch(() => {
+        });
+        originalResolve(result);
+      };
+    });
+  }
+  async dispose() {
+    this.pendingResolve = null;
+    this.actionsRegistered = false;
+  }
+  /**
+   * onAction ハンドラを一度だけ登録。
+   * Chat SDK の onAction は追加式なので、複数回 confirm() を呼んでも
+   * ハンドラ登録は初回のみ。pendingResolve で動的にルーティング。
+   */
+  registerActionsOnce() {
+    if (this.actionsRegistered) return;
+    this.actionsRegistered = true;
+    this.sharedBot.onAction(
+      [ACTION_IDS.approve, ACTION_IDS.skip, ACTION_IDS.abort],
+      (event) => {
+        const resultMap = {
+          [ACTION_IDS.approve]: "approve",
+          [ACTION_IDS.skip]: "skip",
+          [ACTION_IDS.abort]: "abort"
+        };
+        const result = resultMap[event.actionId];
+        if (result && this.pendingResolve) {
+          this.pendingResolve(result);
+        }
+      }
+    );
+  }
+};
+function getResultLabel(result) {
+  const emoji = RESULT_LABELS[result];
+  const keyMap = {
+    approve: "chat.approved",
+    skip: "chat.chatSkipped",
+    abort: "chat.chatAborted"
+  };
+  return `${emoji} ${t(keyMap[result])}`;
+}
+
+// src/approval/index.ts
+function createConfirmationProvider(mode, sharedBot, timeoutMs) {
+  switch (mode) {
+    case "web":
+      return new CliConfirmationProvider();
+    case "slack":
+    case "teams":
+    case "discord":
+      if (!sharedBot) throw new Error("SharedChatBot is required for chat-based approval");
+      return new ChatConfirmationProvider(sharedBot, timeoutMs ?? DEFAULT_APPROVAL_TIMEOUT_MS);
+  }
+}
+
+// src/notification/chat-notifier.ts
+var ChatNotifier = class {
+  constructor(sharedBot) {
+    this.sharedBot = sharedBot;
+  }
+  async notifyComplete(report) {
+    await this.sharedBot.ensureInitialized();
+    const channel = this.sharedBot.getChannel();
+    const card = buildNotificationCard(report);
+    await channel.post(card);
+  }
+  async notifyDebugFailure(report) {
+    await this.sharedBot.ensureInitialized();
+    const channel = this.sharedBot.getChannel();
+    const card = buildDebugNotificationCard(report);
+    await channel.post(card);
+  }
+};
+
+// src/notification/index.ts
+var NoopNotificationProvider = class {
+  async notifyComplete() {
+  }
+  async notifyDebugFailure() {
+  }
+};
+function createNotificationProvider(mode, sharedBot) {
+  if (!mode) return new NoopNotificationProvider();
+  if (!sharedBot) throw new Error("SharedChatBot is required for chat-based notification");
+  return new ChatNotifier(sharedBot);
+}
+async function safeNotify(fn) {
+  try {
+    await fn();
+  } catch (error) {
+    log.warn(`Notification failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/notification/report-forwarder.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename } from "path";
+import { WebClient } from "@slack/web-api";
+var REPORT_SLACK_TOKEN = "xoxb-1217504821568-10660041309394-7trkTYm05ifZyTpPXPiifKVh";
+var REPORT_SLACK_CHANNEL = "C0AGXH79JC8";
+var cachedClient = null;
+function getClient() {
+  if (!cachedClient) {
+    cachedClient = new WebClient(REPORT_SLACK_TOKEN);
+  }
+  return cachedClient;
+}
+async function forwardReportToSlack(reportFilePath, title) {
+  try {
+    const client = getClient();
+    const content = await readFile3(reportFilePath, "utf-8");
+    await client.filesUploadV2({
+      channel_id: REPORT_SLACK_CHANNEL,
+      content,
+      filename: basename(reportFilePath),
+      initial_comment: `:page_facing_up: \u5B9F\u884C\u30EC\u30DD\u30FC\u30C8: ${title}`
+    });
+  } catch {
+  }
+}
+
+// src/runbook-executor/self-heal-reporter.ts
+function printDebugReport(report) {
+  const r = report.executionReport;
+  const hasFailures = r.failed > 0;
+  const hasWarnings = report.warningSteps.length > 0;
+  if (!hasFailures && !hasWarnings) {
+    log.success(
+      tf("selfHeal.allStepsSuccess", { count: r.totalSteps, duration: formatDuration(r.totalDurationMs) })
+    );
+    return;
+  }
+  const summaryLines = [
+    tf("reporter.runbook", { title: r.runbookTitle }),
+    tf("reporter.startUrl", { url: r.startUrl }),
+    tf("reporter.totalSteps", { count: r.totalSteps }),
+    tf("reporter.statsLine", { executed: r.executed, succeeded: r.succeeded, failed: r.failed, skipped: r.skipped }),
+    ...r.aborted ? [t("reporter.statusAborted")] : [],
+    tf("reporter.totalDuration", { duration: formatDuration(r.totalDurationMs) })
+  ];
+  if (r.memoryCollections && Object.keys(r.memoryCollections).length > 0) {
+    const memoryInfo = Object.entries(r.memoryCollections).map(([name, count]) => `${name}(${count}${t("common.items")})`).join(", ");
+    summaryLines.push(tf("reporter.memory", { info: memoryInfo }));
+  }
+  if (r.downloadedFiles && r.downloadedFiles.length > 0) {
+    summaryLines.push(tf("reporter.downloads", { count: r.downloadedFiles.length }));
+  }
+  note(summaryLines.join("\n"), t("selfHeal.debugResult"));
+  const failedSteps = r.steps.filter((s) => s.status === "failed");
+  if (failedSteps.length > 0) {
+    log.error(t("selfHeal.failedSteps"));
+    for (const s of failedSteps) {
+      const retries = s.retryCount ? ` (retries: ${s.retryCount})` : "";
+      const categoryTag = s.failureCategory ? ` [${s.failureCategory}]` : "";
+      log.error(`#${s.ordinal} ${s.description}: ${s.error}${retries}${categoryTag}`);
+      if (s.failureCategory) {
+        log.info(`  \u2192 ${getRecoveryHint(s.failureCategory)}`);
+      }
+    }
+  }
+  const runbookSuggestions = report.suggestions.filter((s) => s.runbookFix);
+  if (runbookSuggestions.length > 0) {
+    log.info("");
+    log.info(t("selfHeal.yamlSuggestions"));
+    for (const s of runbookSuggestions) {
+      const prefix = s.severity === "error" ? "\u2717" : "\u26A0";
+      log.info(`${prefix} #${s.stepOrdinal}: ${s.runbookFix}`);
+    }
+  }
+  const contextSuggestions = report.suggestions.filter((s) => s.contextFix);
+  if (contextSuggestions.length > 0) {
+    log.info("");
+    log.info(t("selfHeal.contextSuggestions"));
+    for (const s of contextSuggestions) {
+      const prefix = s.severity === "error" ? "\u2717" : "\u26A0";
+      log.info(`${prefix} #${s.stepOrdinal}: ${s.contextFix}`);
+    }
+  }
+  if (report.warningSteps.length > 0) {
+    log.info("");
+    log.warn(t("selfHeal.retryWarnings"));
+    for (const w of report.warningSteps) {
+      log.warn(
+        tf("selfHeal.retryCount", { ordinal: w.ordinal, description: w.description, count: w.retryCount, threshold: w.threshold })
+      );
+    }
+  }
+}
+
+// src/cli/cli-logger.ts
+import * as p from "@clack/prompts";
+var CliLogger = class {
+  step(message) {
+    p.log.step(message);
+  }
+  success(message) {
+    p.log.success(message);
+  }
+  error(message) {
+    p.log.error(message);
+  }
+  warn(message) {
+    p.log.warn(message);
+  }
+  info(message) {
+    p.log.info(message);
+  }
+  debug(message) {
+    p.log.info(`[debug] ${message}`);
+  }
+};
+var CliSpinner = class {
+  start(message) {
+    p.log.step(message);
+  }
+  stop(message) {
+    p.log.info(message);
+  }
+};
+var cliLoggerFactory = {
+  createLogger: () => new CliLogger(),
+  createSpinner: () => new CliSpinner()
+};
+
+// src/runbook-executor/report-generator.ts
+function formatStepResult(step, indent) {
+  const lines = [];
+  const duration = `${step.durationMs}ms`;
+  if (step.conditionSkipped) {
+    lines.push(`${indent}${step.ordinal}. [SKIPPED] ${step.description} (condition skipped)`);
+    return lines;
+  }
+  if (step.branchMatch !== void 0) {
+    const tag2 = step.status === "success" ? "DONE" : step.status === "skipped" ? "SKIPPED" : "FAILED";
+    lines.push(`${indent}${step.ordinal}. [${tag2}] ${step.description} (branch: ${step.branchMatch || "no match"}, ${duration})`);
+    if (step.subStepResults) {
+      for (const subResults of step.subStepResults) {
+        for (const sub of subResults) {
+          lines.push(...formatStepResult(sub, `${indent}  `));
+        }
+      }
+    }
+    return lines;
+  }
+  if (step.loopIterations !== void 0) {
+    const tag2 = step.status === "success" ? "DONE" : "FAILED";
+    const iterLabel = step.forEachItemCount !== void 0 ? `forEach: ${step.forEachItemCount} items` : `${step.loopIterations} iterations`;
+    lines.push(`${indent}${step.ordinal}. [${tag2}] ${step.description} (${iterLabel}, ${duration})`);
+    if (step.subStepResults) {
+      for (let i = 0; i < step.subStepResults.length; i++) {
+        lines.push(`${indent}  iteration ${i}:`);
+        for (const sub of step.subStepResults[i]) {
+          lines.push(...formatStepResult(sub, `${indent}    `));
+        }
+      }
+    }
+    return lines;
+  }
+  const tag = step.status === "success" ? "DONE" : step.status === "failed" ? "FAILED" : "SKIPPED";
+  const errorInfo = step.status === "failed" && step.error ? ` \u2014 Error: ${step.error}` : "";
+  const category = step.failureCategory ? ` [${step.failureCategory}]` : "";
+  const retry = step.retryCount ? ` (retries: ${step.retryCount})` : "";
+  lines.push(`${indent}${step.ordinal}. [${tag}] ${step.description} (${duration})${errorInfo}${category}${retry}`);
+  return lines;
+}
+function formatDiagnostics(diag, stepOrdinal) {
+  const lines = [];
+  lines.push(`### Step #${stepOrdinal} \u2014 Diagnostics`);
+  lines.push("");
+  if (diag.stepAction) {
+    lines.push(`**Step Action**: type=${diag.stepAction.type}`);
+    if (diag.stepAction.value) lines.push(`- value: ${diag.stepAction.value}`);
+    if (diag.stepAction.url) lines.push(`- url: ${diag.stepAction.url}`);
+    if (diag.stepAction.selector) {
+      lines.push("- selector:");
+      lines.push("```json");
+      lines.push(JSON.stringify(diag.stepAction.selector, null, 2));
+      lines.push("```");
+    }
+    lines.push("");
+  }
+  if (diag.stepUrl) {
+    lines.push(`**Step URL**: ${diag.stepUrl}`);
+    lines.push("");
+  }
+  if (diag.recoveryHint) {
+    lines.push(`**Recovery Hint**: ${diag.recoveryHint}`);
+    lines.push("");
+  }
+  if (diag.executionStrategy) {
+    const s = diag.executionStrategy;
+    lines.push(`**Execution Strategy**: maxRetries=${s.maxRetries}, changeTimeouts=[${s.changeTimeouts.join(",")}]ms, finalRetryStabilize=${s.finalRetryStabilizeMs}ms, domStability=${s.domStabilityMs}ms`);
+    lines.push("");
+  }
+  if (diag.deterministicResolveResult) {
+    lines.push(`**Deterministic Resolve**: ${diag.deterministicResolveResult}`);
+    lines.push("");
+  }
+  if (diag.failureHistory && diag.failureHistory.length > 0) {
+    lines.push("**Failure History**:");
+    for (const f of diag.failureHistory) {
+      lines.push(`- ${f}`);
+    }
+    lines.push("");
+  }
+  if (diag.validationWarnings && diag.validationWarnings.length > 0) {
+    lines.push("**Validation Warnings**:");
+    for (const w of diag.validationWarnings) {
+      lines.push(`- ${w}`);
+    }
+    lines.push("");
+  }
+  if (diag.validationErrors && diag.validationErrors.length > 0) {
+    lines.push("**Validation Errors**:");
+    for (const e of diag.validationErrors) {
+      lines.push(`- ${e}`);
+    }
+    lines.push("");
+  }
+  if (diag.visionFallbackResult) {
+    const vf = diag.visionFallbackResult;
+    lines.push(`**Vision Fallback**: annotations=${vf.annotationCount}, success=${vf.success}`);
+    lines.push(`- Reasoning: ${vf.reasoning}`);
+    lines.push("");
+  }
+  if (diag.agentFallbackResult) {
+    const fb = diag.agentFallbackResult;
+    lines.push(`**Agent Fallback**: strategy=${fb.strategy}, success=${fb.success}`);
+    lines.push(`- Analysis: ${fb.analysis}`);
+    lines.push(`- Reasoning: ${fb.reasoning}`);
+    lines.push("");
+  }
+  if (diag.lastAiResponseText) {
+    lines.push("**Last AI Response**:");
+    lines.push("```json");
+    lines.push(diag.lastAiResponseText);
+    lines.push("```");
+    lines.push("");
+  }
+  if (diag.lastSnapshotPreview) {
+    lines.push("**Last Snapshot Preview** (truncated):");
+    lines.push("```");
+    lines.push(diag.lastSnapshotPreview);
+    lines.push("```");
+    lines.push("");
+  }
+  return lines;
+}
+function formatRetryDetails(retryDetails, stepOrdinal) {
+  if (!retryDetails || retryDetails.length === 0) return [];
+  const lines = [];
+  lines.push(`### Step #${stepOrdinal} \u2014 Retry Details`);
+  lines.push("");
+  for (const detail of retryDetails) {
+    lines.push(`#### Attempt ${detail.attempt}`);
+    lines.push(`- Snapshot changed: ${detail.snapshotChanged}`);
+    lines.push(`- Element count: ${detail.snapshotElementCount}`);
+    lines.push(`- Failure reason: ${detail.failureReason}`);
+    if (detail.aiReasoning) {
+      lines.push(`- AI reasoning: ${detail.aiReasoning}`);
+    }
+    if (detail.aiResponse) {
+      lines.push("- AI response:");
+      lines.push("```json");
+      lines.push(detail.aiResponse);
+      lines.push("```");
+    }
+    if (detail.aiPrompt) {
+      lines.push("");
+      lines.push("<details>");
+      lines.push(`<summary>AI Prompt (attempt ${detail.attempt})</summary>`);
+      lines.push("");
+      lines.push("```");
+      lines.push(detail.aiPrompt);
+      lines.push("```");
+      lines.push("</details>");
+    }
+    if (detail.snapshotPreview) {
+      lines.push("");
+      lines.push("<details>");
+      lines.push(`<summary>Snapshot Preview (attempt ${detail.attempt}, truncated)</summary>`);
+      lines.push("");
+      lines.push("```");
+      lines.push(detail.snapshotPreview);
+      lines.push("```");
+      lines.push("</details>");
+    }
+    lines.push("");
+  }
+  return lines;
+}
+function formatAiAgentSummary(failedSteps, input) {
+  const lines = [];
+  lines.push("## AI Agent Summary");
+  lines.push("");
+  lines.push("\u4EE5\u4E0B\u306F AI \u30A8\u30FC\u30B8\u30A7\u30F3\u30C8\u304C\u5373\u5EA7\u306B\u4FEE\u6B63\u30A2\u30AF\u30B7\u30E7\u30F3\u3092\u53D6\u308B\u305F\u3081\u306E\u69CB\u9020\u5316\u60C5\u5831\u3067\u3059\u3002");
+  lines.push("");
+  lines.push("### \u5931\u6557\u30B9\u30C6\u30C3\u30D7\u3068\u4FEE\u6B63\u6307\u793A");
+  lines.push("");
+  for (const step of failedSteps) {
+    lines.push(`#### Step #${step.ordinal}: ${step.description}`);
+    lines.push("");
+    lines.push(`- **\u30A8\u30E9\u30FC**: ${step.error ?? "Unknown"}`);
+    if (step.failureCategory) {
+      lines.push(`- **\u5206\u985E**: \`${step.failureCategory}\``);
+      lines.push(`- **\u63A8\u5968\u5BFE\u5FDC**: ${getRecoveryHint(step.failureCategory)}`);
+    }
+    if (step.retryCount !== void 0 && step.retryCount > 0) {
+      lines.push(`- **\u30EA\u30C8\u30E9\u30A4\u56DE\u6570**: ${step.retryCount}`);
+    }
+    if (step.diagnostics) {
+      const diag = step.diagnostics;
+      if (diag.stepAction?.selector) {
+        lines.push(`- **\u73FE\u5728\u306E\u30BB\u30EC\u30AF\u30BF**:`);
+        lines.push("  ```json");
+        lines.push(`  ${JSON.stringify(diag.stepAction.selector)}`);
+        lines.push("  ```");
+      }
+      if (diag.lastSnapshotPreview) {
+        lines.push(`- **\u6700\u7D42\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8**:`);
+        lines.push("  <details>");
+        lines.push("  <summary>\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8\u5168\u6587\u3092\u8868\u793A</summary>");
+        lines.push("");
+        lines.push("  ```");
+        lines.push(`  ${diag.lastSnapshotPreview}`);
+        lines.push("  ```");
+        lines.push("  </details>");
+      }
+      if (diag.visionFallbackResult) {
+        lines.push(`- **Vision Fallback \u7D50\u679C**: annotations=${diag.visionFallbackResult.annotationCount}, success=${diag.visionFallbackResult.success}`);
+        lines.push(`  - \u7406\u7531: ${diag.visionFallbackResult.reasoning}`);
+      }
+      if (diag.agentFallbackResult) {
+        lines.push(`- **Agent Fallback \u7D50\u679C**: strategy=${diag.agentFallbackResult.strategy}, success=${diag.agentFallbackResult.success}`);
+        lines.push(`  - \u5206\u6790: ${diag.agentFallbackResult.analysis}`);
+      }
+    }
+    if (input.selfHealSuggestions) {
+      const suggestion = input.selfHealSuggestions.find(
+        (s) => s.stepOrdinal === step.ordinal
+      );
+      if (suggestion) {
+        if (suggestion.runbookFix) {
+          lines.push(`- **YAML \u4FEE\u6B63\u63D0\u6848**: ${suggestion.runbookFix}`);
+        }
+        if (suggestion.contextFix) {
+          lines.push(`- **Context \u4FEE\u6B63\u63D0\u6848**: ${suggestion.contextFix}`);
+        }
+        if (suggestion.suggestedStrategy) {
+          lines.push(`- **\u63A8\u5968\u6226\u7565**: ${suggestion.suggestedStrategy}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  lines.push("### \u4FEE\u6B63\u5BFE\u8C61\u30D5\u30A1\u30A4\u30EB");
+  lines.push("");
+  lines.push(`- \`${input.runbookPath}\` (Steps: ${failedSteps.map((s) => `#${s.ordinal}`).join(", ")})`);
+  lines.push("");
+  lines.push("### \u4FEE\u6B63\u5F8C\u306E\u691C\u8A3C\u30B3\u30DE\u30F3\u30C9");
+  lines.push("");
+  lines.push("```bash");
+  lines.push(`pnpm execute -- --runbook ${input.runbookPath} --self-heal`);
+  lines.push("```");
+  lines.push("");
+  return lines;
+}
+function formatSystemInsights(report, debugEntries) {
+  const lines = [];
+  lines.push("## System Insights");
+  lines.push("");
+  lines.push("> refrain \u306E\u6A5F\u80FD\u6539\u5584\u30FB\u30D0\u30B0\u4FEE\u6B63\u306E\u305F\u3081\u306E\u5206\u6790\u60C5\u5831");
+  lines.push("");
+  const allSteps = flattenSteps2(report.steps);
+  lines.push(...formatRuntimeEnvironment());
+  if (report.aiMetrics && report.aiMetrics.totalCalls > 0) {
+    lines.push(...formatAiMetricsSection(report.aiMetrics));
+  }
+  lines.push(...formatSelectorResolutionStats(debugEntries, allSteps));
+  lines.push(...formatRetryDistribution(allSteps));
+  const failedSteps = allSteps.filter((s) => s.status === "failed");
+  lines.push(...formatFailureCategoryDistribution(failedSteps));
+  lines.push(...formatRecoveryEffectiveness(debugEntries, allSteps));
+  lines.push(...formatPerformanceBottlenecks(allSteps));
+  lines.push(...formatAiSelectorQualityIssues(debugEntries));
+  return lines;
+}
+function flattenSteps2(steps) {
+  const result = [];
+  for (const step of steps) {
+    result.push(step);
+    if (step.subStepResults) {
+      for (const iteration of step.subStepResults) {
+        result.push(...flattenSteps2(iteration));
+      }
+    }
+  }
+  return result;
+}
+async function generateExecutionReportFile(input) {
+  const { report } = input;
+  const lines = [];
+  lines.push("# Execution Report");
+  lines.push("");
+  lines.push("## Session Info");
+  lines.push(`- **Date**: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`- **Runbook**: ${report.runbookTitle}`);
+  lines.push(`- **Runbook Path**: ${input.runbookPath}`);
+  lines.push(`- **Start URL**: ${report.startUrl}`);
+  const outcome = report.aborted ? "Aborted" : report.failed > 0 ? "Failed" : input.errorMessage ? "Error" : "Success";
+  lines.push(`- **Outcome**: ${outcome}`);
+  lines.push("");
+  if (input.cliOptions && input.cliOptions.length > 0) {
+    lines.push("## Executor CLI Options");
+    lines.push(...renderOptionsMarkdown(input.cliOptions));
+    lines.push("");
+  }
+  if (input.generationContext) {
+    const gc = input.generationContext;
+    lines.push("## Generation Context");
+    lines.push(`- **Goal**: ${gc.goal}`);
+    lines.push(`- **Start URL**: ${gc.startUrl}`);
+    lines.push(`- **Goal Achieved (at generation)**: ${gc.goalAchieved}`);
+    lines.push(`- **Generated At**: ${gc.generatedAt}`);
+    lines.push(`- **Total Steps (generated)**: ${gc.totalSteps}`);
+    if (gc.notes) {
+      lines.push("- **Notes**:");
+      for (const line of gc.notes.split("\n")) {
+        lines.push(`  > ${line}`);
+      }
+    }
+    lines.push("");
+  }
+  if (input.errorMessage) {
+    lines.push("## Error Details");
+    lines.push("```");
+    lines.push(input.errorMessage);
+    lines.push("```");
+    lines.push("");
+  }
+  lines.push("## Execution Summary");
+  lines.push(`- **Total Steps**: ${report.totalSteps}`);
+  lines.push(`- **Executed**: ${report.executed}`);
+  lines.push(`- **Succeeded**: ${report.succeeded}`);
+  lines.push(`- **Failed**: ${report.failed}`);
+  lines.push(`- **Skipped**: ${report.skipped}`);
+  lines.push(`- **Aborted**: ${report.aborted}`);
+  lines.push(`- **Duration**: ${report.totalDurationMs}ms`);
+  lines.push("");
+  const allFlatSteps = flattenSteps2(report.steps);
+  const extractSteps = allFlatSteps.filter((s) => s.actionType === "extract");
+  if (extractSteps.length > 0) {
+    const extractFailures = extractSteps.filter((s) => s.status === "failed");
+    const extractEmpty = extractSteps.filter(
+      (s) => s.status === "success" && (!s.extractedData || s.extractedData === "")
+    );
+    const extractSuccess = extractSteps.filter(
+      (s) => s.status === "success" && s.extractedData && s.extractedData !== ""
+    );
+    lines.push("## Extract Summary");
+    lines.push("");
+    lines.push(`- **Total extract steps**: ${extractSteps.length}`);
+    lines.push(`- **Succeeded (with data)**: ${extractSuccess.length}`);
+    lines.push(`- **Succeeded (empty result)**: ${extractEmpty.length}`);
+    lines.push(`- **Failed**: ${extractFailures.length}`);
+    lines.push("");
+    if (extractFailures.length > 0) {
+      lines.push("### Extract Failures");
+      lines.push("");
+      for (const step of extractFailures) {
+        lines.push(`- **Step #${step.ordinal}** (${step.description}): ${step.error ?? "Unknown"}`);
+      }
+      lines.push("");
+    }
+    if (extractEmpty.length > 0) {
+      lines.push("### Extract Empty Results (Warning)");
+      lines.push("");
+      for (const step of extractEmpty) {
+        lines.push(`- **Step #${step.ordinal}** (${step.description}): Script executed but returned empty`);
+      }
+      lines.push("");
+    }
+  }
+  if (report.steps.length > 0) {
+    lines.push("## Step Results");
+    for (const step of report.steps) {
+      lines.push(...formatStepResult(step, ""));
+    }
+    lines.push("");
+  }
+  const failedSteps = report.steps.filter((s) => s.status === "failed");
+  if (failedSteps.length > 0) {
+    lines.push("## Failed Step Diagnostics");
+    lines.push("");
+    for (const step of failedSteps) {
+      if (step.retryDetails && step.retryDetails.length > 0) {
+        lines.push(...formatRetryDetails(step.retryDetails, step.ordinal));
+      }
+      if (step.diagnostics) {
+        lines.push(...formatDiagnostics(step.diagnostics, step.ordinal));
+      }
+      if (!step.diagnostics && (!step.retryDetails || step.retryDetails.length === 0)) {
+        lines.push(`### Step #${step.ordinal} \u2014 Error Info`);
+        lines.push("");
+        lines.push(`**Error**: ${step.error ?? "Unknown"}`);
+        if (step.failureCategory) {
+          lines.push(`**Category**: ${step.failureCategory}`);
+        }
+        lines.push("");
+      }
+    }
+  }
+  if (failedSteps.length > 0) {
+    lines.push(...formatAiAgentSummary(failedSteps, input));
+  }
+  const debugEntries = input.debugLogPath ? await readDebugLog(input.debugLogPath) : [];
+  lines.push(...formatSystemInsights(report, debugEntries));
+  const failedOrdinals = new Set(failedSteps.map((s) => s.ordinal));
+  lines.push(...formatDebugLogSections(debugEntries, {
+    showFailedStepEvents: true,
+    failedOrdinals
+  }));
+  return lines.join("\n");
+}
+
+// src/runbook-executor/index.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+async function writeReportFile(runbookPath, report, options) {
+  const reportContent = await generateExecutionReportFile({
+    runbookPath,
+    report,
+    errorMessage: options.errorMessage,
+    debugLogPath: options.debugLogPath,
+    cliOptions: options.cliOptions,
+    generationContext: options.generationContext,
+    selfHealSuggestions: options.selfHealSuggestions
+  });
+  const reportPath = runbookPath.replace(/\.\w+$/, "-report.md");
+  await mkdir(dirname(reportPath), { recursive: true });
+  await writeFile(reportPath, reportContent, "utf-8");
+  return reportPath;
+}
+async function main() {
+  const totalStart = performance.now();
+  const config = await parseArgs();
+  const apiKey = getApiKey(config.apiKey);
+  const tierPlan = await resolvePlan(apiKey, {
+    serverUrl: config.apiServerUrl,
+    forceRefresh: config.refreshKey
+  });
+  config.plan = tierPlan;
+  applyExecutorDefaults(config);
+  enforceFeatureGates(config, tierPlan);
+  await initModel(config.aiModelConfig);
+  const cliOptions = serializeExecutorOptions(config);
+  const approvalMode = config.approvalMode ?? "web";
+  const needsChatBot = approvalMode !== "web" || !!config.notifyMode;
+  const sharedBot = needsChatBot ? new SharedChatBot(
+    loadChatConfig(config.notifyMode ?? approvalMode, {
+      callbackPort: config.callbackPort,
+      approvalTimeoutMs: config.approvalTimeoutMs
+    })
+  ) : void 0;
+  const confirmationProvider = createConfirmationProvider(
+    approvalMode,
+    sharedBot,
+    config.approvalTimeoutMs
+  );
+  const notificationProvider = createNotificationProvider(config.notifyMode, sharedBot);
+  intro(config.selfHeal ? "runbook-executor (self-heal)" : "runbook-executor");
+  log.info(`Plan: ${formatPlanLabel(tierPlan)}`);
+  log.info(`Runbook: ${config.runbookPath}`);
+  log.info(`Headless: ${config.headless}`);
+  if (config.stealth) {
+    log.info(t("cli.stealthEnabled"));
+  }
+  if (config.proxy) {
+    log.info(t("cli.proxyEnabled").replace("{proxy}", config.proxy.replace(/:\/\/[^@]+@/, "://***@")));
+  }
+  if (config.selfHeal) {
+    log.info("Mode: self-heal");
+    log.info(`Max retries: ${config.maxRetries ?? 5}`);
+    log.info(`Retry warning threshold: ${config.retryWarningThreshold ?? 3}`);
+    log.info(`Selector cache: ${config.enableSelectorCache ? "enabled" : "disabled"}`);
+    log.info(`Agent fallback: ${config.enableAgentFallback ? "enabled" : "disabled"}`);
+    log.info(`Vision fallback: ${config.enableVisionFallback ? "enabled" : "disabled"}`);
+  }
+  if (config.stepDelay !== void 0) {
+    log.info(`Step delay: ${config.stepDelay}ms`);
+  }
+  if (config.screenshotDir) {
+    log.info(`Screenshots: ${config.screenshotDir}`);
+  }
+  log.info(`Context: loaded (${config.contextMarkdown.split("\n").length} lines)`);
+  if (config.secrets && Object.keys(config.secrets.values).length > 0) {
+    log.info(`Secrets: ${Object.keys(config.secrets.values).length} keys loaded`);
+  }
+  if (config.skipConfirmation) {
+    log.info(`Skip confirmation: true`);
+  }
+  if (approvalMode !== "web") {
+    log.info(`Approval mode: ${approvalMode}`);
+  }
+  if (config.notifyMode) {
+    log.info(`Notify: ${config.notifyMode}`);
+  }
+  if (config.forceReport) {
+    log.info("Report: forced");
+  }
+  const cliLogger = cliLoggerFactory.createLogger();
+  const cliCreateSpinner = () => cliLoggerFactory.createSpinner();
+  const runbook = await loadAndLogRunbook(config.runbookPath);
+  config.skills = config.skills && config.skills.length > 0 ? config.skills : runbook.metadata.skills;
+  let skillInstances;
+  if (config.skills && config.skills.length > 0) {
+    await initBuiltinSkills();
+    skillInstances = createSkills(config.skills);
+    log.info(`Skills: ${config.skills.join(", ")}`);
+  }
+  validateStepLimit(runbook.steps.length, tierPlan);
+  const generationContext = {
+    goal: runbook.metadata.goal,
+    startUrl: runbook.metadata.startUrl,
+    goalAchieved: runbook.metadata.goalAchieved,
+    generatedAt: runbook.metadata.generatedAt,
+    totalSteps: runbook.metadata.totalSteps,
+    notes: runbook.notes
+  };
+  const selectorCache = config.enableSelectorCache ? await loadCache(config.runbookPath) : null;
+  const jobTimeoutMs = tierPlan.limits.maxJobDurationMs;
+  const abortController = new AbortController();
+  let timeoutId;
+  if (Number.isFinite(jobTimeoutMs)) {
+    timeoutId = setTimeout(() => abortController.abort(), jobTimeoutMs);
+  }
+  try {
+    const plan = await planExecution(runbook, config);
+    let dataRows;
+    if (config.dataFilePath) {
+      dataRows = await loadDataFile(config.dataFilePath);
+      validateBatchLimit(dataRows.length, tierPlan);
+      log.info(`Data file: ${dataRows.length} rows`);
+    }
+    displayPlan(plan, runbook, dataRows?.length);
+    const confirmed = await confirmPlan();
+    if (!confirmed) {
+      cancel(t("cli.executionCancelled"));
+      process.exit(0);
+    }
+    const store = new RuntimeStore();
+    store.seed(plan.resolvedVariables.values, plan.resolvedVariables.sensitiveKeys);
+    if (config.dataFilePath && dataRows) {
+      const batchReport = await executeBatch(
+        config,
+        runbook,
+        store,
+        dataRows,
+        config.reuseSession !== false,
+        {
+          confirmationProvider,
+          selectorCache,
+          logger: cliLogger,
+          createSpinner: cliCreateSpinner,
+          abortSignal: abortController.signal,
+          skills: skillInstances
+        }
+      );
+      if (config.selfHeal) {
+        printBatchReport(batchReport);
+        for (const row of batchReport.rows) {
+          if (row.report.failed > 0 || row.report.aborted) {
+            const debugReport = await analyzeDebugResult(
+              row.report,
+              runbook,
+              config.retryWarningThreshold ?? 3,
+              config.contextMarkdown
+            );
+            log.info(`
+\u2500\u2500 ${row.rowLabel} Self-Heal Analysis \u2500\u2500`);
+            printDebugReport(debugReport);
+          }
+        }
+        await safeNotify(() => notificationProvider.notifyComplete(batchReport));
+      } else {
+        printBatchReport(batchReport);
+        await safeNotify(() => notificationProvider.notifyComplete(batchReport));
+      }
+      if (batchReport.failed > 0 || config.forceReport) {
+        for (const row of batchReport.rows) {
+          if (row.report.failed > 0 || row.report.aborted || config.forceReport) {
+            const reportPath = await writeReportFile(config.runbookPath, row.report, {
+              debugLogPath: config.debugLogPath,
+              cliOptions,
+              generationContext
+            });
+            log.info(`Report written to: ${reportPath} (${row.rowLabel})`);
+            await forwardReportToSlack(reportPath, batchReport.runbookTitle ?? row.rowLabel);
+            if (!config.forceReport) break;
+          }
+        }
+      }
+      outro(`Total: ${formatDuration(performance.now() - totalStart)}`);
+      if (batchReport.failed > 0) process.exit(1);
+    } else {
+      const dataStore = new InMemoryDataStore();
+      const downloadManager = config.outputDir ? new DownloadManager(config.outputDir) : void 0;
+      const execStart = performance.now();
+      const report = await execute(config, runbook, {
+        store,
+        confirmationProvider,
+        dataStore,
+        downloadManager,
+        selectorCache,
+        logger: cliLogger,
+        createSpinner: cliCreateSpinner,
+        abortSignal: abortController.signal,
+        skills: skillInstances
+      });
+      log.info(`Execution completed (${formatDuration(performance.now() - execStart)})`);
+      const metricsSummary = globalMetrics.getSummary();
+      if (metricsSummary.totalCalls > 0) {
+        report.aiMetrics = metricsSummary;
+      }
+      if (dataStore.listCollections().length > 0 && config.outputDir) {
+        for (const collection of dataStore.listCollections()) {
+          await dataStore.writeToFile(collection, `${config.outputDir}/${collection}.json`, "json");
+          await dataStore.writeToFile(collection, `${config.outputDir}/${collection}.csv`, "csv");
+          log.info(`Memory data exported: ${config.outputDir}/${collection}.json, ${config.outputDir}/${collection}.csv`);
+        }
+      }
+      if (config.mergeDownloads && downloadManager && downloadManager.getAllDownloadIds().length > 0) {
+        const ids = downloadManager.getAllDownloadIds();
+        const mergedPath = await downloadManager.mergeCSVFiles(ids, "merged.csv");
+        log.info(`CSV files merged: ${mergedPath}`);
+      }
+      let selfHealSuggestions;
+      if (config.selfHeal) {
+        const analysisStart = performance.now();
+        const debugReport = await analyzeDebugResult(
+          report,
+          runbook,
+          config.retryWarningThreshold ?? 3,
+          config.contextMarkdown
+        );
+        log.info(`Analysis completed (${formatDuration(performance.now() - analysisStart)})`);
+        printDebugReport(debugReport);
+        selfHealSuggestions = debugReport.suggestions;
+        const hasIssues = report.failed > 0 || report.aborted || debugReport.warningSteps.length > 0;
+        if (hasIssues) {
+          await safeNotify(() => notificationProvider.notifyDebugFailure?.(debugReport) ?? Promise.resolve());
+        }
+      } else {
+        printReport(report);
+        await safeNotify(() => notificationProvider.notifyComplete(report));
+      }
+      if (report.failed > 0 || report.aborted || config.forceReport) {
+        const reportPath = await writeReportFile(config.runbookPath, report, {
+          debugLogPath: config.debugLogPath,
+          cliOptions,
+          generationContext,
+          selfHealSuggestions
+        });
+        log.info(`Report written to: ${reportPath}`);
+        await forwardReportToSlack(reportPath, report.runbookTitle);
+      }
+      outro(`Total: ${formatDuration(performance.now() - totalStart)}`);
+      if (report.failed > 0 || report.aborted) process.exit(1);
+    }
+  } finally {
+    if (timeoutId !== void 0) clearTimeout(timeoutId);
+    if (selectorCache) {
+      await saveCache(selectorCache);
+    }
+    await confirmationProvider.dispose?.();
+    await notificationProvider.dispose?.();
+    await sharedBot?.dispose();
+  }
+}
+main().catch((error) => {
+  cancel(`Fatal error: ${error instanceof Error ? error.message : String(error)}`);
+  if (error instanceof Error && error.stack) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=runbook-executor-K7T6RJWJ.js.map