@refrainai/cli 0.4.1 → 0.4.3

package/dist/{chunk-H47NWH7N.js → chunk-AOCGSFRM.js}

@@ -3,45 +3,65 @@ import {
   AgentBrowser,
   NoopLogger,
   NoopSpinner,
-  buildFallbackMessages,
-  buildSelectorMessages,
-  buildSuggestionUserPrompt,
-  buildVisionMessages,
   classifyFailure,
-  countElements,
   createDebugLogger,
-  findElementInSnapshot,
+  formatAiMetricsSection,
+  formatAiSelectorQualityFromSteps,
+  formatAiSelectorQualityIssues,
+  formatDebugLogSections,
   formatDuration,
+  formatFailureCategoryDistribution,
+  formatPerformanceBottlenecks,
+  formatRecoveryEffectiveness,
+  formatRecoveryEffectivenessFromTelemetry,
+  formatRetryDistribution,
+  formatRuntimeEnvironment,
+  formatSelectorResolutionStats,
+  formatSelectorResolutionStatsFromTelemetry,
   getRecoveryHint,
-  getSuggestionSystemPrompt,
-  parseAllElements,
   parseAndAppendToMemory,
+  readDebugLog,
+  renderOptionsMarkdown,
   sanitizeBrowserError,
   sleep
-} from "./chunk-DJVUITRB.js";
-import {
-  filterSnapshot
-} from "./chunk-XMFCXPYU.js";
+} from "./chunk-ZEBQWBEU.js";
 import {
   resolveTemplate
 } from "./chunk-D5SI2PHK.js";
 import {
   formatRiskHint,
-  getLocale,
   log,
   note,
   promptConfirm,
   promptSelect,
-  promptText,
-  t,
-  tf
-} from "./chunk-7UCVPKD4.js";
+  promptText
+} from "./chunk-NRKZJVPE.js";
 import {
   getActiveMetricsCollector,
   getModel,
   trackedGenerateObject,
   withAIRetry
-} from "./chunk-UGPXCQY3.js";
+} from "./chunk-KFNW4XR2.js";
+import {
+  filterSnapshot
+} from "./chunk-XMFCXPYU.js";
+import {
+  countElements,
+  findElementInSnapshot,
+  parseAllElements
+} from "./chunk-YTVEYQGA.js";
+import {
+  buildFallbackMessages,
+  buildSelectorMessages,
+  buildSuggestionUserPrompt,
+  buildVisionMessages,
+  getSuggestionSystemPrompt
+} from "./chunk-GC7I5SGK.js";
+import {
+  getLocale,
+  t,
+  tf
+} from "./chunk-6FGCPMBU.js";
 
 // src/runbook-executor/types.ts
 var SELF_HEAL_DEFAULTS = {
@@ -1526,6 +1546,9 @@ function toNumber(val) {
   return Number.isNaN(n) ? 0 : n;
 }
 
+// src/runbook-executor/executor.ts
+import { z as z5 } from "zod";
+
 // src/context/snapshot-cache.ts
 import { createHash as createHash4 } from "crypto";
 var SnapshotCache = class {
@@ -2049,13 +2072,19 @@ async function execute(config, runbook, opts) {
           step: step.ordinal,
           data: { error: rawErrorMsg }
         });
+        const actionFailureCategory = classifyFailure({
+          error: rawErrorMsg,
+          selectorResolved: true,
+          actionExecuted: true
+        });
         results.push({
           ordinal: step.ordinal,
           description: step.description,
           actionType: step.action.type,
           status: "failed",
           durationMs: Date.now() - start,
-          error: errorMsg
+          error: errorMsg,
+          failureCategory: actionFailureCategory
         });
         await opts.onStepFailed?.(step.ordinal, errorMsg).catch(() => {
         });
@@ -2617,43 +2646,105 @@ async function executeStep(browser, step, runbook, config, opts, debugLogger, lo
   }
   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");
+    if (script) {
+      logger.step(`Extract: executing script`);
       debugLogger.log({
         phase: "executor",
-        event: "extract_empty_result",
+        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.extractPrompt) {
+      const prompt = opts.store.resolveTemplate(step.action.extractPrompt);
+      logger.step(`Extract: AI extraction`);
+      debugLogger.log({
+        phase: "executor",
+        event: "extract",
+        step: step.ordinal,
+        data: { extractPrompt: prompt.slice(0, 200) }
+      });
+      const snapshot = await browser.snapshot();
+      const extractSchema = z5.object({ data: z5.string() });
+      const model = opts.aiProvider ? opts.aiProvider.getModel("extraction") : getModel("extraction");
+      const { EXTRACT_SYSTEM_PROMPT } = await import("./extraction-prompt-VDCKIFLB.js");
+      const goalContext = runbook.metadata?.goal ? `
+
+\u62BD\u51FA\u306E\u76EE\u6A19:
+${runbook.metadata.goal}` : "";
+      const aiResult2 = await trackedGenerateObject("extraction", {
+        model,
+        system: EXTRACT_SYSTEM_PROMPT,
+        prompt: `${prompt}${goalContext}
+
+\u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8:
+${snapshot}`,
+        schema: extractSchema,
+        temperature: 0
+      });
+      const resultStr = aiResult2.object?.data ?? "";
+      debugLogger.log({
+        phase: "executor",
+        event: "extract_result",
+        step: step.ordinal,
+        data: {
+          resultType: "string (AI)",
+          resultPreview: resultStr.slice(0, 200),
+          storedLength: resultStr.length
+        }
+      });
+      if (resultStr === "") {
+        logger.warn("Extract (AI) returned empty result");
+        debugLogger.log({
+          phase: "executor",
+          event: "extract_empty_result",
+          step: step.ordinal,
+          data: { extractPrompt: prompt.slice(0, 200) }
+        });
+      }
+      return { status: "success", durationMs: Date.now() - start, extractedData: resultStr };
     }
-    return { status: "success", durationMs: Date.now() - start, extractedData: resultStr };
+    return {
+      status: "failed",
+      durationMs: Date.now() - start,
+      error: "extract requires script, extractPrompt, or value",
+      diagnostics: {
+        stepAction: {
+          type: step.action.type,
+          value: step.action.value,
+          script: step.action.script,
+          extractPrompt: step.action.extractPrompt
+        },
+        recoveryHint: "extract \u30B9\u30C6\u30C3\u30D7\u306B script\uFF08JavaScript\uFF09\u307E\u305F\u306F extractPrompt\uFF08AI\u62BD\u51FA\u30D7\u30ED\u30F3\u30D7\u30C8\uFF09\u3092\u8A2D\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044"
+      }
+    };
   }
   if (step.action.type === "export") {
     if (!opts.dataStore) {
@@ -2762,6 +2853,7 @@ async function executeStep(browser, step, runbook, config, opts, debugLogger, lo
   let lastAiResponseText = "";
   let lastAiPrompt = "";
   let attempts = 0;
+  const resolvedDescription = opts.store.resolveTemplate(step.description);
   const failureHistory = [];
   const retryDetails = [];
   let cachedRefUsed = false;
@@ -2962,11 +3054,11 @@ async function executeStep(browser, step, runbook, config, opts, debugLogger, lo
       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 relevantContext = contextChunker ? contextChunker.selectRelevant(resolvedDescription, step.url) : config.contextMarkdown;
     const detailed = await resolveWithAIDetailed(
       filteredSnap,
       step.action.selector,
-      step.description,
+      resolvedDescription,
       step.url,
       relevantContext,
       debugLogger,
@@ -3014,11 +3106,11 @@ async function executeStep(browser, step, runbook, config, opts, debugLogger, lo
           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 relevantCtx = contextChunker ? contextChunker.selectRelevant(resolvedDescription, step.url) : config.contextMarkdown;
         const recoveryResult = await resolveWithAIDetailed(
           filteredScrollSnap,
           step.action.selector,
-          step.description,
+          resolvedDescription,
           step.url,
           relevantCtx,
           debugLogger,
@@ -3066,7 +3158,7 @@ async function executeStep(browser, step, runbook, config, opts, debugLogger, lo
         imageBuffer,
         annotations,
         step.action.selector,
-        step.description,
+        resolvedDescription,
         step.url,
         failureHistory,
         debugLogger,
@@ -3108,10 +3200,10 @@ async function executeStep(browser, step, runbook, config, opts, debugLogger, lo
       data: { failureHistory }
     });
     logger.warn("Attempting agent fallback...");
-    const fallbackContext = contextChunker ? contextChunker.selectRelevant(step.description, step.url) : config.contextMarkdown;
+    const fallbackContext = contextChunker ? contextChunker.selectRelevant(resolvedDescription, step.url) : config.contextMarkdown;
     const fallbackResult = await runGoalAgent(
       browser,
-      { description: step.description, action: step.action },
+      { description: resolvedDescription, action: step.action },
       failureHistory,
       fallbackContext,
       debugLogger,
@@ -3432,9 +3524,9 @@ function countSnapshotElements(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")
+import { z as z6 } from "zod";
+var contextValuesSchema = z6.object({
+  values: z6.record(z6.string(), z6.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",
@@ -3606,6 +3698,25 @@ async function planExecution(runbook, config) {
     log.info(tf("planner.extractedFromContext", { count: coreResult.contextExtractedKeys.size }));
   }
   const captureVarNames = new Set(coreResult.captureVars);
+  if (!config.skipConfirmation) {
+    const promptVarsToEdit = Object.entries(variables).filter(
+      ([name, def]) => def.source === "prompt" && !coreResult.unresolvedDataVars.includes(name) && !captureVarNames.has(name)
+    );
+    if (promptVarsToEdit.length > 0) {
+      log.step(t("planner.promptVariables"));
+      for (const [name, def] of promptVarsToEdit) {
+        const currentValue = coreResult.values.get(name) ?? def.value ?? "";
+        const answer = await promptText(
+          def.description ?? name,
+          {
+            initialValue: currentValue,
+            placeholder: def.value || t("planner.placeholder")
+          }
+        );
+        coreResult.values.set(name, answer.trim());
+      }
+    }
+  }
   const stillUnresolved = Object.entries(variables).filter(
     ([name, def]) => !coreResult.values.has(name) && !coreResult.unresolvedDataVars.includes(name) && !captureVarNames.has(name) && def.required !== false
   );
@@ -4056,20 +4167,20 @@ function parseIntEnv(key) {
 }
 
 // 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(
+import { z as z7 } from "zod";
+var suggestionSchema = z7.array(
+  z7.object({
+    stepOrdinal: z7.number().describe("\u5931\u6557\u3057\u305F\u30B9\u30C6\u30C3\u30D7\u306E ordinal"),
+    stepDescription: z7.string().describe("\u30B9\u30C6\u30C3\u30D7\u306E\u8AAC\u660E"),
+    error: z7.string().describe("\u5931\u6557\u30A8\u30E9\u30FC\u306E\u8981\u7D04"),
+    runbookFix: z7.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(
+    contextFix: z7.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([
+    severity: z7.enum(["error", "warning"]).describe("error: \u5B9F\u884C\u4E0D\u53EF\u3001warning: \u4E0D\u5B89\u5B9A"),
+    failureCategory: z7.enum([
       "element_not_found",
       "element_stale",
       "page_structure_changed",
@@ -4077,7 +4188,7 @@ var suggestionSchema = z6.array(
       "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")
+    suggestedStrategy: z7.string().optional().describe("\u30AB\u30C6\u30B4\u30EA\u306B\u57FA\u3065\u304F\u63A8\u5968\u5BFE\u5FDC")
   })
 );
 async function analyzeDebugResult(report, runbook, retryWarningThreshold, contextMarkdown, aiProvider) {
@@ -4152,6 +4263,432 @@ ${retryInfo}${categoryInfo}`;
   }
 }
 
+// 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})` : "";
+  let resolveInfo = "";
+  if (step.resolveMethod) {
+    resolveInfo = ` [resolved: ${step.resolveMethod}]`;
+    if (step.resolveMethod === "deterministic" && step.deterministicMatchType) {
+      const confStr = step.deterministicConfidence != null ? `, conf: ${step.deterministicConfidence.toFixed(2)}` : "";
+      resolveInfo += ` (match: ${step.deterministicMatchType}${confStr})`;
+    }
+  }
+  lines.push(`${indent}${step.ordinal}. [${tag}] ${step.description} (${duration})${resolveInfo}${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.script) lines.push(`- script: ${diag.stepAction.script.slice(0, 200)}`);
+    if (diag.stepAction.extractPrompt) lines.push(`- extractPrompt: ${diag.stepAction.extractPrompt.slice(0, 200)}`);
+    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, telemetryStats) {
+  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 = flattenSteps(report.steps);
+  lines.push(...formatRuntimeEnvironment());
+  if (report.aiMetrics && report.aiMetrics.totalCalls > 0) {
+    lines.push(...formatAiMetricsSection(report.aiMetrics));
+  }
+  if (debugEntries.length > 0) {
+    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));
+  } else if (telemetryStats) {
+    lines.push(...formatSelectorResolutionStatsFromTelemetry(telemetryStats, allSteps));
+    lines.push(...formatRetryDistribution(allSteps));
+    const failedSteps = allSteps.filter((s) => s.status === "failed");
+    lines.push(...formatFailureCategoryDistribution(failedSteps));
+    lines.push(...formatRecoveryEffectivenessFromTelemetry(telemetryStats, allSteps));
+    lines.push(...formatPerformanceBottlenecks(allSteps));
+    lines.push(...formatAiSelectorQualityFromSteps(allSteps));
+  } else {
+    lines.push(...formatRetryDistribution(allSteps));
+    const failedSteps = allSteps.filter((s) => s.status === "failed");
+    lines.push(...formatFailureCategoryDistribution(failedSteps));
+    lines.push(...formatPerformanceBottlenecks(allSteps));
+  }
+  return lines;
+}
+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;
+}
+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 = flattenSteps(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, input.telemetryStats));
+  const failedOrdinals = new Set(failedSteps.map((s) => s.ordinal));
+  lines.push(...formatDebugLogSections(debugEntries, {
+    showFailedStepEvents: true,
+    failedOrdinals
+  }));
+  return lines.join("\n");
+}
+
 // src/messaging/cards.ts
 import {
   Card,
@@ -4422,6 +4959,7 @@ export {
   buildNotificationCard,
   buildDebugNotificationCard,
   buildGenerateNotificationCard,
-  analyzeDebugResult
+  analyzeDebugResult,
+  generateExecutionReportFile
 };
-//# sourceMappingURL=chunk-H47NWH7N.js.map
+//# sourceMappingURL=chunk-AOCGSFRM.js.map