@refrainai/cli 0.4.1

package/dist/runbook-generator-MPXJBQ5N.js

@@ -0,0 +1,800 @@
+#!/usr/bin/env node
+import {
+  buildRunbookYaml,
+  createReviewPrompt,
+  explore,
+  reviewResponseSchema
+} from "./chunk-IGFCYKHC.js";
+import {
+  formatAiMetricsSection,
+  formatDebugLogSections,
+  formatFailureCategoryDistribution,
+  formatPerformanceBottlenecks,
+  formatRuntimeEnvironment,
+  readDebugLog,
+  renderOptionsMarkdown,
+  serializeGeneratorOptions
+} from "./chunk-VPK2MQAZ.js";
+import {
+  checkHelpFlag,
+  getRawArgs,
+  parseModelConfig,
+  readContextFile
+} from "./chunk-2BVDAJZT.js";
+import {
+  createDebugLogger,
+  formatDuration,
+  loadSecrets
+} from "./chunk-DJVUITRB.js";
+import "./chunk-XMFCXPYU.js";
+import "./chunk-AG3CFMYU.js";
+import {
+  cancel,
+  getLocale,
+  initLocale,
+  intro,
+  log,
+  note,
+  outro,
+  promptMultiselect,
+  promptSelect,
+  promptText,
+  t,
+  tf
+} from "./chunk-7UCVPKD4.js";
+import {
+  getModel,
+  globalMetrics,
+  initModel,
+  trackedGenerateObject
+} from "./chunk-UGPXCQY3.js";
+import "./chunk-RT664YIO.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/runbook-generator/index.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+
+// src/runbook-generator/config.ts
+import { parseArgs as nodeParseArgs } from "util";
+async function parseArgs() {
+  checkHelpFlag("generate");
+  const args = getRawArgs();
+  const { values } = nodeParseArgs({
+    args,
+    options: {
+      url: { type: "string" },
+      goal: { type: "string" },
+      output: { type: "string" },
+      screenshots: { type: "string" },
+      context: { type: "string" },
+      secrets: { type: "string" },
+      "max-iterations": { type: "string" },
+      "step-delay": { type: "string" },
+      "stall-check-interval": { type: "string" },
+      "history-window": { type: "string" },
+      "max-failures": { type: "string" },
+      "no-snapshot-filter": { type: "boolean" },
+      "debug-log": { type: "string" },
+      debug: { type: "boolean" },
+      headless: { type: "string" },
+      model: { type: "string" },
+      "model-provider": { type: "string" },
+      "model-base-url": { type: "string" },
+      "model-selector": { type: "string" },
+      "model-extraction": { type: "string" },
+      "model-exploration": { type: "string" },
+      "model-review": { type: "string" },
+      "model-fallback": { type: "string" },
+      "model-exploration-light": { type: "string" },
+      "enable-multi-model": { type: "boolean" },
+      video: { type: "string" },
+      locale: { type: "string" },
+      stealth: { type: "boolean" },
+      proxy: { type: "string" },
+      skill: { type: "string" }
+    },
+    strict: true
+  });
+  initLocale(values.locale);
+  if (!values.url) {
+    cancel(t("cli.urlRequired"));
+    process.exit(1);
+  }
+  if (!values.goal) {
+    cancel(t("cli.goalRequired"));
+    process.exit(1);
+  }
+  if (!values.output) {
+    cancel(t("cli.outputRequired"));
+    process.exit(1);
+  }
+  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);
+  return {
+    url: values.url,
+    goal: values.goal,
+    locale: getLocale(),
+    output: values.output,
+    screenshotDir: values.screenshots,
+    contextMarkdown,
+    secrets,
+    maxIterations: values["max-iterations"] ? Number.parseInt(values["max-iterations"], 10) : 20,
+    stepDelay: values["step-delay"] ? Number.parseInt(values["step-delay"], 10) : 500,
+    headless: values.headless !== "false",
+    stallCheckInterval: values["stall-check-interval"] ? Number.parseInt(values["stall-check-interval"], 10) : 3,
+    historyWindow: values["history-window"] ? Number.parseInt(values["history-window"], 10) : 10,
+    maxConsecutiveFailures: values["max-failures"] ? Number.parseInt(values["max-failures"], 10) : 3,
+    snapshotFilter: !values["no-snapshot-filter"],
+    debugLogPath: values["debug-log"],
+    debugConsole: values.debug ?? false,
+    videoDir: values.video,
+    aiModelConfig,
+    enableMultiModel: values["enable-multi-model"] ?? false,
+    stealth: values.stealth ?? false,
+    proxy: values.proxy,
+    skills: values.skill?.split(",").map((s) => s.trim()).filter(Boolean)
+  };
+}
+
+// src/runbook-generator/review-editor.ts
+function buildSummaryText(reviewResult, recordedSteps, humanGuidance) {
+  const lines = [];
+  const keptSteps = reviewResult.reviewedSteps.filter((s) => s.keep);
+  if (keptSteps.length > 0) {
+    lines.push(t("review.keptSteps"));
+    for (const step of keptSteps) {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      lines.push(
+        `  #${step.originalOrdinal}: ${desc} [risk: ${step.riskLevel}]`
+      );
+    }
+  }
+  const confirmSteps = keptSteps.filter((s) => s.requiresConfirmation);
+  lines.push("");
+  lines.push(t("review.confirmationRequired"));
+  if (confirmSteps.length > 0) {
+    for (const step of confirmSteps) {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      const reason = step.confirmationReason ? ` \u2014 ${step.confirmationReason}` : "";
+      lines.push(
+        `  #${step.originalOrdinal}: ${desc} [risk: ${step.riskLevel}]${reason}`
+      );
+    }
+  } else {
+    lines.push("  " + t("common.none"));
+  }
+  const removedSteps = reviewResult.reviewedSteps.filter((s) => !s.keep);
+  if (removedSteps.length > 0) {
+    lines.push("");
+    lines.push(t("review.removedSteps"));
+    for (const step of removedSteps) {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      const reason = step.removalReason ?? "";
+      lines.push(`  #${step.originalOrdinal}: ${desc} (\u7406\u7531: ${reason})`);
+    }
+  }
+  const captureSteps = recordedSteps.filter(
+    (r) => r.action.suggestedCaptures && r.action.suggestedCaptures.length > 0
+  );
+  if (captureSteps.length > 0) {
+    lines.push("");
+    lines.push(t("review.capturedValues"));
+    for (const r of captureSteps) {
+      for (const c of r.action.suggestedCaptures) {
+        lines.push(
+          `  Step #${r.ordinal} \u2192 ${c.name} (${c.strategy}${c.pattern ? `: ${c.pattern}` : ""})`
+        );
+      }
+    }
+  }
+  lines.push("");
+  lines.push(t("review.notes"));
+  if (humanGuidance.length > 0) {
+    for (const [i, n] of humanGuidance.entries()) {
+      lines.push(`  ${tf("review.guidancePrefix", { index: i + 1 })} ${n}`);
+    }
+  } else {
+    lines.push("  " + t("common.none"));
+  }
+  lines.push("");
+  lines.push(tf("review.summaryLabel", { summary: reviewResult.summary }));
+  return lines.join("\n");
+}
+function cloneReviewResult(r) {
+  return {
+    reviewedSteps: r.reviewedSteps.map((s) => ({ ...s })),
+    summary: r.summary
+  };
+}
+function deriveSuggestedNotes(reviewResult, recordedSteps) {
+  const suggestions = [];
+  const highRiskSteps = reviewResult.reviewedSteps.filter(
+    (s) => s.keep && s.riskLevel === "high"
+  );
+  if (highRiskSteps.length > 0) {
+    const ordinals = highRiskSteps.map((s) => `#${s.originalOrdinal}`).join(", ");
+    suggestions.push(tf("review.highRiskNote", { ordinals }));
+  }
+  const credentialSteps = recordedSteps.filter(
+    (r) => r.action.inputCategory === "credential"
+  );
+  if (credentialSteps.length > 0) {
+    suggestions.push(t("review.credentialNote"));
+  }
+  const removedCount = reviewResult.reviewedSteps.filter(
+    (s) => !s.keep
+  ).length;
+  if (removedCount >= 3) {
+    suggestions.push(tf("review.removedStepsNote", { count: removedCount }));
+  }
+  if (reviewResult.summary) {
+    suggestions.push(`AI\u30EC\u30D3\u30E5\u30FC\u8981\u7D04: ${reviewResult.summary}`);
+  }
+  return suggestions;
+}
+async function handleToggleConfirmation(reviewResult, recordedSteps) {
+  const keptSteps = reviewResult.reviewedSteps.filter((s) => s.keep);
+  if (keptSteps.length === 0) {
+    log.warn("\u4FDD\u6301\u3055\u308C\u308B\u30B9\u30C6\u30C3\u30D7\u304C\u3042\u308A\u307E\u305B\u3093\u3002");
+    return;
+  }
+  const initialValues = keptSteps.filter((s) => s.requiresConfirmation).map((s) => s.originalOrdinal);
+  const selected = await promptMultiselect(
+    t("review.selectConfirmSteps"),
+    keptSteps.map((step) => {
+      const recorded = recordedSteps.find(
+        (r) => r.ordinal === step.originalOrdinal
+      );
+      const desc = recorded?.action.description ?? t("common.unknown");
+      return {
+        value: step.originalOrdinal,
+        label: `#${step.originalOrdinal}: ${desc}`,
+        hint: `risk: ${step.riskLevel}`
+      };
+    }),
+    { initialValues }
+  );
+  for (const step of keptSteps) {
+    step.requiresConfirmation = selected.includes(step.originalOrdinal);
+  }
+}
+async function handleEditNotes(humanGuidance, reviewResult, recordedSteps) {
+  const suggestions = deriveSuggestedNotes(reviewResult, recordedSteps);
+  const options = [
+    { value: "add_custom", label: t("review.addCustomNote") }
+  ];
+  if (suggestions.length > 0) {
+    options.push({
+      value: "add_suggested",
+      label: t("review.addSuggestedNote"),
+      hint: `${suggestions.length} ${t("common.items")}`
+    });
+  }
+  if (humanGuidance.length > 0) {
+    options.push({
+      value: "delete",
+      label: t("review.deleteNote"),
+      hint: `${humanGuidance.length} ${t("common.items")}`
+    });
+  }
+  const action = await promptSelect(
+    t("review.selectNotesAction"),
+    options
+  );
+  switch (action) {
+    case "add_custom": {
+      const content = await promptText(t("review.noteContent"), {
+        validate: (v) => !v?.trim() ? t("review.noteContentRequired") : void 0
+      });
+      humanGuidance.push(content.trim());
+      log.success(tf("review.notesAdded", { count: 1 }));
+      break;
+    }
+    case "add_suggested": {
+      const selected = await promptMultiselect(
+        "\u8FFD\u52A0\u3059\u308B\u30CE\u30FC\u30C8\u3092\u9078\u629E",
+        suggestions.map((s, i) => ({
+          value: i,
+          label: s
+        }))
+      );
+      for (const idx of selected) {
+        humanGuidance.push(suggestions[idx]);
+      }
+      log.success(tf("review.notesAdded", { count: selected.length }));
+      break;
+    }
+    case "delete": {
+      const toDelete = await promptMultiselect(
+        "\u524A\u9664\u3059\u308B\u30CE\u30FC\u30C8\u3092\u9078\u629E",
+        humanGuidance.map((g, i) => ({
+          value: i,
+          label: `${tf("review.guidancePrefix", { index: i + 1 })} ${g}`
+        }))
+      );
+      for (const idx of [...toDelete].sort((a, b) => b - a)) {
+        humanGuidance.splice(idx, 1);
+      }
+      log.success(tf("review.notesDeleted", { count: toDelete.length }));
+      break;
+    }
+  }
+}
+async function handleEditCaptures(recordedSteps) {
+  const action = await promptSelect(
+    t("review.selectCaptureAction"),
+    [
+      { value: "accept_all", label: t("review.acceptAllCaptures") },
+      { value: "reject", label: t("review.rejectCaptures") },
+      { value: "add", label: t("review.addCapture") }
+    ]
+  );
+  switch (action) {
+    case "accept_all": {
+      log.success(t("review.allCapturesAccepted"));
+      break;
+    }
+    case "reject": {
+      const captureSteps = recordedSteps.filter(
+        (r) => r.action.suggestedCaptures && r.action.suggestedCaptures.length > 0
+      );
+      if (captureSteps.length === 0) {
+        log.warn(t("review.noCapturesAvailable"));
+        break;
+      }
+      const allCaptures = [];
+      for (const r of captureSteps) {
+        for (const c of r.action.suggestedCaptures) {
+          allCaptures.push({
+            value: `${r.ordinal}:${c.name}`,
+            label: `Step #${r.ordinal} \u2192 ${c.name} (${c.strategy})`
+          });
+        }
+      }
+      const toReject = await promptMultiselect(
+        t("review.selectCapturesToReject"),
+        allCaptures
+      );
+      for (const key of toReject) {
+        const [ordStr, name] = key.split(":");
+        const step = recordedSteps.find((r) => r.ordinal === Number(ordStr));
+        if (step?.action.suggestedCaptures) {
+          step.action.suggestedCaptures = step.action.suggestedCaptures.filter(
+            (c) => c.name !== name
+          );
+        }
+      }
+      log.success(tf("review.capturesRejected", { count: toReject.length }));
+      break;
+    }
+    case "add": {
+      const ordinalStr = await promptText(t("review.captureStepNumber"), {
+        validate: (v) => {
+          if (!v?.trim()) return t("review.captureStepRequired");
+          if (Number.isNaN(Number(v))) return t("review.captureStepNumeric");
+          return void 0;
+        }
+      });
+      const ordinal = Number(ordinalStr);
+      const step = recordedSteps.find((r) => r.ordinal === ordinal);
+      if (!step) {
+        log.warn(tf("review.stepNotFound", { ordinal }));
+        break;
+      }
+      const name = await promptText(t("review.captureVarName"), {
+        validate: (v) => !v?.trim() ? t("review.captureVarRequired") : void 0
+      });
+      const strategy = await promptSelect(
+        t("review.captureStrategy"),
+        [
+          { value: "snapshot", label: t("review.strategySnapshot") },
+          { value: "url", label: t("review.strategyUrl") },
+          { value: "ai", label: t("review.strategyAi") },
+          { value: "expression", label: t("review.strategyExpression") }
+        ]
+      );
+      const newCapture = { name, strategy };
+      if (strategy === "snapshot" || strategy === "url") {
+        newCapture.pattern = await promptText(t("review.regexPattern"));
+      } else if (strategy === "ai") {
+        newCapture.prompt = await promptText(t("review.aiExtractionPrompt"));
+      } else if (strategy === "expression") {
+        newCapture.expression = await promptText(t("review.templateExpression"));
+      }
+      if (!step.action.suggestedCaptures) {
+        step.action.suggestedCaptures = [];
+      }
+      step.action.suggestedCaptures.push(newCapture);
+      log.success(tf("review.captureAdded", { ordinal, name }));
+      break;
+    }
+  }
+}
+async function promptReviewEdits(reviewResult, recordedSteps, humanGuidance) {
+  const edited = cloneReviewResult(reviewResult);
+  const editedGuidance = [...humanGuidance];
+  while (true) {
+    const summaryText = buildSummaryText(edited, recordedSteps, editedGuidance);
+    note(summaryText, t("review.reviewResult"));
+    const hasCaptureSteps = recordedSteps.some(
+      (r) => r.action.suggestedCaptures && r.action.suggestedCaptures.length > 0
+    );
+    const menuOptions = [
+      { value: "confirm", label: t("review.confirm"), hint: t("review.confirmHint") },
+      {
+        value: "toggle_confirmation",
+        label: t("review.toggleConfirmation"),
+        hint: "multiselect"
+      },
+      ...hasCaptureSteps ? [
+        {
+          value: "edit_captures",
+          label: t("review.editCaptures"),
+          hint: t("review.editCapturesHint")
+        }
+      ] : [],
+      { value: "edit_notes", label: t("review.editNotes") }
+    ];
+    const action = await promptSelect(
+      t("review.selectAction"),
+      menuOptions
+    );
+    if (action === "confirm") {
+      break;
+    }
+    switch (action) {
+      case "toggle_confirmation":
+        await handleToggleConfirmation(edited, recordedSteps);
+        break;
+      case "edit_captures":
+        await handleEditCaptures(recordedSteps);
+        break;
+      case "edit_notes":
+        await handleEditNotes(editedGuidance, edited, recordedSteps);
+        break;
+    }
+  }
+  return {
+    reviewResult: edited,
+    humanGuidance: editedGuidance
+  };
+}
+
+// src/runbook-generator/report-generator.ts
+function formatOutcome(outcome) {
+  switch (outcome) {
+    case "cancelled":
+      return "Cancelled by user";
+    case "goal_achieved":
+      return "Goal achieved";
+    case "goal_not_achieved":
+      return "Goal not achieved";
+    case "error":
+      return "Error";
+  }
+}
+function toReportableSteps(steps) {
+  return steps.map((s) => ({
+    ordinal: s.ordinal + 1,
+    description: `${s.action.action}: ${s.action.description}`,
+    status: s.success ? "success" : "failed",
+    durationMs: s.durationMs ?? 0,
+    error: s.error,
+    failureCategory: s.failureCategory
+  }));
+}
+async function generateExplorationReport(input) {
+  const lines = [];
+  lines.push("# Exploration Report");
+  lines.push("");
+  lines.push("## Session Info");
+  lines.push(`- **Date**: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push(`- **Goal**: ${input.goal}`);
+  lines.push(`- **Start URL**: ${input.startUrl}`);
+  lines.push(`- **Outcome**: ${formatOutcome(input.outcome)}`);
+  lines.push("");
+  if (input.cliOptions && input.cliOptions.length > 0) {
+    lines.push("## CLI Options");
+    lines.push(...renderOptionsMarkdown(input.cliOptions));
+    lines.push("");
+  }
+  lines.push("## User Feedback");
+  if (input.userFeedback) {
+    lines.push(input.userFeedback);
+  } else {
+    lines.push("(No feedback provided)");
+  }
+  lines.push("");
+  if (input.errorMessage) {
+    lines.push("## Error Details");
+    lines.push("```");
+    lines.push(input.errorMessage);
+    lines.push("```");
+    lines.push("");
+  }
+  const successCount = input.recordedSteps.filter((s) => s.success).length;
+  const failedCount = input.recordedSteps.filter((s) => !s.success).length;
+  lines.push("## Execution Summary");
+  lines.push(`- **Total Steps**: ${input.recordedSteps.length}`);
+  lines.push(`- **Successful**: ${successCount}`);
+  lines.push(`- **Failed**: ${failedCount}`);
+  lines.push(`- **Interventions**: ${input.interventions.length}`);
+  if (input.totalDurationMs !== void 0) {
+    lines.push(`- **Duration**: ${input.totalDurationMs}ms`);
+  }
+  lines.push("");
+  if (input.recordedSteps.length > 0) {
+    lines.push("## Recorded Steps");
+    for (const step of input.recordedSteps) {
+      const tag = step.success ? "DONE" : "FAILED";
+      const errorInfo = !step.success && step.error ? ` \u2014 Error: ${step.error}` : "";
+      const category = step.failureCategory ? ` [${step.failureCategory}]` : "";
+      const duration = step.durationMs !== void 0 ? ` (${step.durationMs}ms)` : "";
+      lines.push(
+        `${step.ordinal + 1}. [${tag}] ${step.action.action}: ${step.action.description} (URL: ${step.url})${duration}${errorInfo}${category}`
+      );
+    }
+    lines.push("");
+  }
+  if (input.interventions.length > 0) {
+    lines.push("## Interventions");
+    for (const iv of input.interventions) {
+      lines.push(
+        `- **Step ${iv.stepIndex}** (${iv.timestamp}): "${iv.userInstruction}" (URL: ${iv.url})`
+      );
+    }
+    lines.push("");
+  }
+  const debugEntries = input.debugLogPath ? await readDebugLog(input.debugLogPath) : [];
+  const reportableSteps = toReportableSteps(input.recordedSteps);
+  const hasInsights = input.aiMetrics && input.aiMetrics.totalCalls > 0 || reportableSteps.some((s) => s.status === "failed") || reportableSteps.some((s) => s.durationMs > 3e3) || debugEntries.length > 0;
+  if (hasInsights) {
+    lines.push("## System Insights");
+    lines.push("");
+    lines.push("> refrain \u306E\u6A5F\u80FD\u6539\u5584\u30FB\u30D0\u30B0\u4FEE\u6B63\u306E\u305F\u3081\u306E\u5206\u6790\u60C5\u5831");
+    lines.push("");
+    lines.push(...formatRuntimeEnvironment());
+    if (input.aiMetrics && input.aiMetrics.totalCalls > 0) {
+      lines.push(...formatAiMetricsSection(input.aiMetrics));
+    }
+    const failedSteps = reportableSteps.filter((s) => s.status === "failed");
+    lines.push(...formatFailureCategoryDistribution(failedSteps));
+    lines.push(...formatPerformanceBottlenecks(reportableSteps));
+  }
+  lines.push(...formatDebugLogSections(debugEntries));
+  return lines.join("\n");
+}
+
+// src/runbook-generator/index.ts
+async function main() {
+  const totalStart = performance.now();
+  const config = await parseArgs();
+  await initModel(config.aiModelConfig);
+  const cliOptions = serializeGeneratorOptions(config);
+  intro("runbook-generator");
+  log.info(`URL:    ${config.url}`);
+  log.info(`Goal:   ${config.goal}`);
+  log.info(`Output: ${config.output}`);
+  log.info(`Max iterations: ${config.maxIterations}`);
+  log.info(`Step delay: ${config.stepDelay}ms`);
+  log.info(`Headless: ${config.headless}`);
+  if (config.skills && config.skills.length > 0) {
+    log.info(`Skills: ${config.skills.join(", ")}`);
+  }
+  log.info(`Context: loaded (${config.contextMarkdown.split("\n").length} lines)`);
+  log.info("--- Context Markdown ---");
+  log.info(config.contextMarkdown);
+  log.info("--- End Context ---");
+  if (config.secrets && Object.keys(config.secrets.values).length > 0) {
+    log.info(`Secrets: ${Object.keys(config.secrets.values).length} keys loaded`);
+  }
+  const exploreStart = performance.now();
+  const { recordedSteps, goalAchieved, additionalGuidance, interventions, cancelled, error: exploreError } = await explore(config);
+  log.info(`Steps recorded: ${recordedSteps.length}`);
+  log.info(`Goal achieved: ${goalAchieved}`);
+  if (cancelled) {
+    log.warn("Exploration was cancelled by user.");
+  }
+  if (interventions.length > 0) {
+    log.info(`User interventions: ${interventions.length}`);
+  }
+  log.info(`Exploration completed (${formatDuration(performance.now() - exploreStart)})`);
+  if (exploreError) {
+    log.error(`Exploration failed: ${exploreError.message}`);
+    const report = await generateExplorationReport({
+      goal: config.goal,
+      startUrl: config.url,
+      outcome: "error",
+      userFeedback: "",
+      recordedSteps,
+      interventions,
+      debugLogPath: config.debugLogPath,
+      errorMessage: exploreError.stack ?? exploreError.message,
+      cliOptions,
+      aiMetrics: globalMetrics.getSummary(),
+      totalDurationMs: Math.round(performance.now() - totalStart)
+    });
+    const reportPath = config.output.replace(/\.\w+$/, "-report.md");
+    await mkdir(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, report, "utf-8");
+    log.info(`Error report written to: ${reportPath}`);
+    outro(`Exploration failed. Report: ${reportPath}`);
+    process.exit(1);
+  }
+  if (cancelled || !goalAchieved) {
+    const userFeedback = await promptText(
+      t("generator.feedbackPrompt"),
+      { validate: () => void 0 }
+    );
+    const report = await generateExplorationReport({
+      goal: config.goal,
+      startUrl: config.url,
+      outcome: cancelled ? "cancelled" : "goal_not_achieved",
+      userFeedback: userFeedback?.trim() ?? "",
+      recordedSteps,
+      interventions,
+      debugLogPath: config.debugLogPath,
+      cliOptions,
+      aiMetrics: globalMetrics.getSummary(),
+      totalDurationMs: Math.round(performance.now() - totalStart)
+    });
+    const reportPath = config.output.replace(/\.\w+$/, "-report.md");
+    await mkdir(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, report, "utf-8");
+    log.info(`Report written to: ${reportPath}`);
+    if (cancelled) {
+      outro(t("generator.cancelled"));
+      process.exit(0);
+    }
+  }
+  if (recordedSteps.length === 0) {
+    log.error("No steps recorded. Cannot generate runbook.");
+    process.exit(1);
+  }
+  try {
+    const debugLogger = createDebugLogger({
+      filePath: config.debugLogPath,
+      console: config.debugConsole
+    });
+    let reviewResult;
+    try {
+      const reviewStart = performance.now();
+      log.step(t("generator.aiReviewing"));
+      const { system: reviewSystem, userPrompt: reviewUserPrompt } = createReviewPrompt(
+        config.goal,
+        recordedSteps,
+        goalAchieved,
+        interventions,
+        config.locale
+      );
+      debugLogger.log({
+        phase: "generator",
+        event: "ai_review",
+        data: { prompt: `${reviewSystem}
+---
+${reviewUserPrompt}`.slice(0, 500) }
+      });
+      const { object } = await trackedGenerateObject("review", {
+        model: getModel("review"),
+        messages: [
+          {
+            role: "system",
+            content: reviewSystem,
+            providerOptions: {
+              anthropic: { cacheControl: { type: "ephemeral" } }
+            }
+          },
+          { role: "user", content: reviewUserPrompt }
+        ],
+        schema: reviewResponseSchema,
+        temperature: 0
+      });
+      reviewResult = object;
+      debugLogger.log({
+        phase: "generator",
+        event: "ai_review",
+        data: {
+          parsedResult: reviewResult
+        }
+      });
+      const kept = reviewResult.reviewedSteps.filter((s) => s.keep).length;
+      const removed = reviewResult.reviewedSteps.filter((s) => !s.keep).length;
+      log.info(`AI review done: ${kept} kept, ${removed} removed (${formatDuration(performance.now() - reviewStart)})`);
+      log.info(`Summary: ${reviewResult.summary}`);
+    } catch (error) {
+      log.warn(tf("generator.aiReviewFailed", { error: error instanceof Error ? error.message : String(error) }));
+      reviewResult = void 0;
+    }
+    let finalGuidance = additionalGuidance;
+    if (reviewResult) {
+      const edited = await promptReviewEdits(
+        reviewResult,
+        recordedSteps,
+        additionalGuidance
+      );
+      reviewResult = edited.reviewResult;
+      finalGuidance = edited.humanGuidance;
+    }
+    if (reviewResult) {
+      const keptWithConfirm = reviewResult.reviewedSteps.filter((s) => s.keep && s.requiresConfirmation).map((s) => `#${s.originalOrdinal}`);
+      log.info(`Confirmation required for steps: ${keptWithConfirm.join(", ") || t("common.none")}`);
+    }
+    const yamlStart = performance.now();
+    const yaml = buildRunbookYaml({
+      goal: config.goal,
+      startUrl: config.url,
+      recordedSteps,
+      goalAchieved,
+      stepDelay: config.stepDelay,
+      contextMarkdown: config.contextMarkdown,
+      reviewResult,
+      humanGuidance: finalGuidance,
+      interventions,
+      skills: config.skills
+    });
+    await mkdir(dirname(config.output), { recursive: true });
+    await writeFile(config.output, yaml, "utf-8");
+    log.info(`YAML generation + write (${formatDuration(performance.now() - yamlStart)})`);
+    await debugLogger.flush();
+    log.success(`Runbook written to: ${config.output}`);
+    if (!goalAchieved) {
+      log.warn("Goal was NOT fully achieved. Runbook may be incomplete.");
+    }
+    const metrics = globalMetrics.getSummary();
+    if (metrics.totalCalls > 0) {
+      const purposeSummary = Object.entries(metrics.byPurpose).map(([p, b]) => `${p}(${b.calls})`).join(" ");
+      log.info(
+        `AI Metrics: ${metrics.totalCalls} calls, ${metrics.totalInputTokens.toLocaleString()} in / ${metrics.totalOutputTokens.toLocaleString()} out tokens, cache ${(metrics.cacheHitRate * 100).toFixed(1)}%, $${metrics.estimatedCostUsd.toFixed(4)}, ${(metrics.totalDurationMs / 1e3).toFixed(1)}s \u2014 ${purposeSummary}`
+      );
+      if (metrics.byModel && Object.keys(metrics.byModel).length > 1) {
+        const modelSummary = Object.entries(metrics.byModel).map(([id, b]) => `${id}($${b.estimatedCostUsd.toFixed(4)})`).join(" ");
+        log.info(`Models: ${modelSummary}`);
+      }
+    }
+    outro(`Total: ${formatDuration(performance.now() - totalStart)}`);
+  } catch (postExploreError) {
+    const errorMessage = postExploreError instanceof Error ? postExploreError.stack ?? postExploreError.message : String(postExploreError);
+    log.error(`Post-exploration phase failed: ${errorMessage}`);
+    const report = await generateExplorationReport({
+      goal: config.goal,
+      startUrl: config.url,
+      outcome: "error",
+      userFeedback: "",
+      recordedSteps,
+      interventions,
+      debugLogPath: config.debugLogPath,
+      errorMessage,
+      cliOptions,
+      aiMetrics: globalMetrics.getSummary(),
+      totalDurationMs: Math.round(performance.now() - totalStart)
+    });
+    const reportPath = config.output.replace(/\.\w+$/, "-report.md");
+    await mkdir(dirname(reportPath), { recursive: true });
+    await writeFile(reportPath, report, "utf-8");
+    log.info(`Error report written to: ${reportPath}`);
+    process.exit(1);
+  }
+}
+main().catch((error) => {
+  cancel(`Fatal error: ${error instanceof Error ? error.message : String(error)}`);
+  if (error instanceof Error && error.stack) {
+    console.error(error.stack);
+  }
+  process.exit(1);
+});
+//# sourceMappingURL=runbook-generator-MPXJBQ5N.js.map