@refrainai/cli 0.4.1 → 0.4.2

package/dist/{chunk-IGFCYKHC.js → chunk-CNJ5KCDN.js}

@@ -5,18 +5,29 @@ import {
   InMemoryDataStore,
   classifyFailure,
   createDebugLogger,
-  createReviewUserPrompt,
-  findElementInSnapshot,
+  formatAiMetricsSection,
+  formatDebugLogSections,
   formatDuration,
-  getAgentInstructions,
-  getInitialUserMessage,
-  getReviewSystemPrompt,
+  formatFailureCategoryDistribution,
+  formatPerformanceBottlenecks,
+  formatRuntimeEnvironment,
   noopLogger,
-  parseAllElements,
   parseAndAppendToMemory,
+  readDebugLog,
+  renderOptionsMarkdown,
   sanitizeBrowserError,
   sleep
-} from "./chunk-DJVUITRB.js";
+} from "./chunk-ELQ23L4Z.js";
+import {
+  log,
+  promptSelect,
+  promptText
+} from "./chunk-XIVS7N3V.js";
+import {
+  getModel,
+  trackedGenerateObject,
+  trackedGenerateText
+} from "./chunk-KFNW4XR2.js";
 import {
   filterSnapshot
 } from "./chunk-XMFCXPYU.js";
@@ -24,22 +35,22 @@ import {
   createSkills,
   initBuiltinSkills
 } from "./chunk-AG3CFMYU.js";
+import {
+  buildSelector
+} from "./chunk-RBZK7T76.js";
+import {
+  findElementInSnapshot,
+  parseAllElements
+} from "./chunk-YTVEYQGA.js";
+import {
+  getAgentInstructions,
+  getInitialUserMessage
+} from "./chunk-EMAYENG4.js";
 import {
   getLocale,
-  log,
-  promptSelect,
-  promptText,
   t,
   tf
-} from "./chunk-7UCVPKD4.js";
-import {
-  getModel,
-  trackedGenerateObject,
-  trackedGenerateText
-} from "./chunk-UGPXCQY3.js";
-import {
-  ParsedRunbookSchema
-} from "./chunk-RT664YIO.js";
+} from "./chunk-F7WTOQIQ.js";
 
 // src/runbook-generator/exploration-agent.ts
 import { stepCountIs } from "ai";
@@ -49,53 +60,6 @@ import { z as z2 } from "zod";
 import { tool } from "ai";
 import { z } from "zod";
 
-// src/browser/selector-builder.ts
-var ROLE_TAG_MAP = {
-  textbox: { tagName: "input", inputType: "text" },
-  button: { tagName: "button", role: "button" },
-  link: { tagName: "a", role: "link" },
-  checkbox: { tagName: "input", inputType: "checkbox" },
-  radio: { tagName: "input", inputType: "radio" },
-  combobox: { tagName: "select", role: "combobox" },
-  searchbox: { tagName: "input", inputType: "search" },
-  slider: { tagName: "input", inputType: "range" },
-  spinbutton: { tagName: "input", inputType: "number" },
-  switch: { tagName: "input", inputType: "checkbox", role: "switch" },
-  tab: { tagName: "button", role: "tab" },
-  menuitem: { tagName: "button", role: "menuitem" },
-  option: { tagName: "option", role: "option" },
-  heading: { tagName: "h2", role: "heading" },
-  img: { tagName: "img", role: "img" },
-  navigation: { tagName: "nav", role: "navigation" },
-  listitem: { tagName: "li", role: "listitem" }
-};
-function buildSelector(element) {
-  const mapping = ROLE_TAG_MAP[element.role];
-  const tagName = mapping?.tagName ?? element.role;
-  const selector = { tagName };
-  if (mapping?.role) {
-    selector.role = mapping.role;
-  } else if (element.role !== tagName) {
-    selector.role = element.role;
-  }
-  if (mapping?.inputType) {
-    selector.inputType = mapping.inputType;
-  }
-  if (element.name) {
-    selector.ariaLabel = element.name;
-    if (element.role === "button" || element.role === "link") {
-      selector.innerText = element.name.slice(0, 200);
-    }
-  }
-  if (element.attributes.placeholder) {
-    selector.placeholder = element.attributes.placeholder;
-  }
-  if (element.attributes.name) {
-    selector.name = element.attributes.name;
-  }
-  return selector;
-}
-
 // src/harness/loop-detector.ts
 function stepHash(step) {
   const urlPath = extractPath(step.url);
@@ -583,11 +547,16 @@ ${finalSnapshot2}`;
                   data: { extractPrompt: action.extractPrompt.slice(0, 200) }
                 });
                 const snapshot = await browser.snapshot();
-                const { getModel: getModel2, trackedGenerateObject: trackedGenerateObject2 } = await import("./ai-model-FM6GWCID.js");
+                const { getModel: getModel2, trackedGenerateObject: trackedGenerateObject2 } = await import("./ai-model-DP5PKGM6.js");
+                const { EXTRACT_SYSTEM_PROMPT } = await import("./extraction-prompt-VDCKIFLB.js");
                 const extractSchema = z.object({ data: z.string() });
                 const aiResult = await trackedGenerateObject2("extraction", {
                   model: getModel2("extraction"),
-                  prompt: `${action.extractPrompt}
+                  system: EXTRACT_SYSTEM_PROMPT,
+                  prompt: `${action.extractPrompt}${config.goal ? `
+
+\u62BD\u51FA\u306E\u76EE\u6A19:
+${config.goal}` : ""}
 
 \u30B9\u30CA\u30C3\u30D7\u30B7\u30E7\u30C3\u30C8:
 ${snapshot}`,
@@ -1108,7 +1077,8 @@ async function exploreWithAI(browser, recordedSteps, config, dataStore, download
     paginationTracker,
     onToolCallStart: config.onToolCallStart,
     onToolCallEnd: config.onToolCallEnd,
-    skills: config.skills
+    skills: config.skills,
+    goal: config.goal
   };
   const browserTool = createBrowserTool(browser, recordedSteps, toolConfig, dataStore, downloadManager);
   const totalMaxSteps = config.maxIterations * 3;
@@ -1635,6 +1605,7 @@ async function explore(config, options) {
     const maxSteps = config.maxIterations * 3;
     log.step(t("generator.waitingForAI"));
     interventionController.startListening();
+    let lastReportedStepCount = 0;
     const agentStart = performance.now();
     const result = await exploreWithAI(browser, recordedSteps, {
       goal: config.goal,
@@ -1655,15 +1626,17 @@ async function explore(config, options) {
         log.step(tf("generator.exploringStep", { current: stepCount + 1, total: maxSteps }));
       },
       onToolCallEnd: () => {
-        const lastStep = recordedSteps[recordedSteps.length - 1];
-        if (lastStep && options?.onExplorerStep) {
+        if (!options?.onExplorerStep) return;
+        const newSteps = recordedSteps.slice(lastReportedStepCount);
+        for (const step of newSteps) {
           options.onExplorerStep(
-            recordedSteps.length,
-            lastStep.action.description ?? lastStep.action.action,
-            lastStep
+            step.ordinal + 1,
+            step.action.description ?? step.action.action,
+            step
           ).catch(() => {
           });
         }
+        lastReportedStepCount = recordedSteps.length;
       }
     }, dataStore, downloadManager);
     interventionController.dispose();
@@ -1735,240 +1708,224 @@ async function explore(config, options) {
   }
 }
 
-// src/runbook-generator/runbook-builder.ts
-import { stringify } from "yaml";
-function toActionType(action) {
-  switch (action) {
-    case "fill":
-    case "type":
-      return "input";
-    case "check":
-    case "uncheck":
-    case "click":
-      return "click";
-    case "select":
-      return "select";
-    case "navigate":
-      return "navigate";
-    case "scroll":
-      return "scroll";
-    case "wait":
-      return "wait";
-    case "extract":
-      return "extract";
-    case "download":
-      return "download";
-    case "export":
-      return "export";
-    case "memory_append":
-    case "memory_aggregate":
-      return "memory";
-    case "key":
-      return "key";
-    default:
-      return "click";
+// 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 categoryToSource(category) {
-  switch (category) {
-    case "credential":
-      return "prompt";
-    case "user_data":
-      return "prompt";
-    case "fixed":
-      return "fixed";
-    case "navigation":
-      return "fixed";
-    default:
-      return "prompt";
-  }
+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
+  }));
 }
-function buildRunbookYaml(input) {
-  const { goal, startUrl, recordedSteps, goalAchieved, stepDelay, reviewResult, humanGuidance, interventions } = input;
-  const successfulSteps = recordedSteps.filter((s) => s.success);
-  const reviewMap = new Map(
-    reviewResult?.reviewedSteps.map((r) => [r.originalOrdinal, r])
-  );
-  const filteredSteps = reviewResult ? successfulSteps.filter((s) => reviewMap.get(s.ordinal)?.keep !== false) : successfulSteps;
-  const variables = {};
-  const usedVariableNames = /* @__PURE__ */ new Set();
-  filteredSteps.forEach((recorded) => {
-    const { action } = recorded;
-    const actionType = toActionType(action.action);
-    if (actionType === "input" && action.value !== void 0) {
-      const varName = action.variableName ?? `input_${recorded.ordinal}`;
-      if (!usedVariableNames.has(varName)) {
-        usedVariableNames.add(varName);
-        const source = categoryToSource(action.inputCategory);
-        variables[varName] = {
-          source,
-          description: action.description,
-          ...source === "prompt" && {
-            required: true,
-            sensitive: action.inputCategory === "credential"
-          },
-          ...source === "fixed" && { value: action.value }
-        };
-      }
+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}`
+      );
     }
-  });
-  const steps = filteredSteps.map((recorded, index) => {
-    const actionType = toActionType(recorded.action.action);
-    const review = reviewMap.get(recorded.ordinal);
-    let selector;
-    if (recorded.action.selector) {
-      const ref = recorded.action.selector.replace("@", "");
-      const element = findElementInSnapshot(recorded.snapshotBefore, ref);
-      if (element) {
-        selector = buildSelector(element);
-      } else if (recorded.resolvedElement) {
-        selector = recorded.resolvedElement;
-      } else {
-        selector = { tagName: "unknown" };
+    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");
+}
+var SNAPSHOT_PREVIEW_LIMIT = 500;
+async function generateGenerationReportFile(input) {
+  const lines = [];
+  lines.push("# Generation 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**: ${input.goalAchieved ? "Goal achieved" : "Goal not achieved"}`);
+  lines.push(`- **Total Recorded Steps**: ${input.recordedSteps.length}`);
+  lines.push("");
+  if (input.errorMessage) {
+    lines.push("## Error Details");
+    lines.push("```");
+    lines.push(input.errorMessage);
+    lines.push("```");
+    lines.push("");
+  }
+  if (input.generateConfig) {
+    const gc = input.generateConfig;
+    lines.push("## Generation Config");
+    lines.push(`- **Max Iterations**: ${gc.maxIterations}`);
+    if (gc.modelId) lines.push(`- **Model**: ${gc.modelId}${gc.modelProvider ? ` (${gc.modelProvider})` : ""}`);
+    lines.push(`- **Headless**: ${gc.headless}`);
+    lines.push(`- **Stealth**: ${gc.stealth}`);
+    lines.push(`- **Snapshot Filter**: ${gc.snapshotFilter}`);
+    lines.push("");
+  }
+  const successCount = input.recordedSteps.filter((s) => s.success).length;
+  const failedCount = input.recordedSteps.filter((s) => !s.success).length;
+  const totalDurationMs = input.recordedSteps.reduce((sum, s) => sum + (s.durationMs ?? 0), 0);
+  lines.push("## Execution Summary");
+  lines.push(`- **Total Steps**: ${input.recordedSteps.length}`);
+  lines.push(`- **Successful**: ${successCount}`);
+  lines.push(`- **Failed**: ${failedCount}`);
+  lines.push(`- **Duration**: ${totalDurationMs}ms`);
+  lines.push("");
+  if (input.recordedSteps.length > 0) {
+    lines.push("## Recorded Steps");
+    lines.push("");
+    for (const step of input.recordedSteps) {
+      const tag = step.success ? "DONE" : "FAILED";
+      const duration = step.durationMs !== void 0 ? ` (${step.durationMs}ms)` : "";
+      lines.push(`### Step #${step.ordinal + 1} \u2014 [${tag}] ${step.action.action}: ${step.action.description}${duration}`);
+      lines.push("");
+      lines.push(`- **URL**: ${step.url}`);
+      if (step.action.selector) lines.push(`- **Selector**: ${step.action.selector}`);
+      if (step.action.value) lines.push(`- **Value**: ${step.action.value}`);
+      if (step.action.inputCategory) lines.push(`- **Input Category**: ${step.action.inputCategory}`);
+      if (step.action.variableName) lines.push(`- **Variable Name**: ${step.action.variableName}`);
+      if (!step.success && step.error) lines.push(`- **Error**: ${step.error}`);
+      if (step.failureCategory) lines.push(`- **Failure Category**: ${step.failureCategory}`);
+      if (step.snapshotBefore) {
+        const preview = step.snapshotBefore.length > SNAPSHOT_PREVIEW_LIMIT ? `${step.snapshotBefore.slice(0, SNAPSHOT_PREVIEW_LIMIT)}\u2026` : step.snapshotBefore;
+        lines.push("- **Snapshot Preview**:");
+        lines.push("```");
+        lines.push(preview);
+        lines.push("```");
       }
+      lines.push("");
     }
-    let value;
-    if (actionType === "input" && recorded.action.value !== void 0) {
-      const varName = recorded.action.variableName ?? `input_${recorded.ordinal}`;
-      value = `{{${varName}}}`;
+  }
+  if (input.reviewResult) {
+    lines.push("## AI Review Summary");
+    lines.push(`- **Goal Achieved**: ${input.reviewResult.goalAchieved ?? "unknown"}`);
+    if (input.reviewResult.summary) {
+      lines.push(`- **Summary**: ${input.reviewResult.summary}`);
     }
-    const step = {
-      ordinal: index,
-      description: recorded.action.description,
-      action: {
-        type: actionType,
-        ...selector && { selector },
-        ...actionType === "input" && value !== void 0 && { value },
-        ...actionType === "select" && recorded.action.value !== void 0 && {
-          optionText: recorded.action.value
-        },
-        ...actionType === "navigate" && recorded.action.value && {
-          url: recorded.action.value
-        },
-        ...actionType === "extract" && recorded.action.script && {
-          script: recorded.action.script
-        },
-        ...actionType === "download" && recorded.action.downloadPath && {
-          downloadPath: recorded.action.downloadPath
-        },
-        ...actionType === "export" && recorded.action.exportCollection && {
-          exportCollection: recorded.action.exportCollection
-        },
-        ...actionType === "export" && recorded.action.exportFormat && {
-          exportFormat: recorded.action.exportFormat
-        },
-        ...actionType === "export" && recorded.action.exportPath && {
-          exportPath: recorded.action.exportPath
-        },
-        ...actionType === "key" && {
-          keys: recorded.action.keys ?? recorded.action.value
-        }
-      },
-      url: recorded.url,
-      riskLevel: review?.riskLevel ?? "low",
-      requiresConfirmation: review?.requiresConfirmation ?? false
-    };
-    const captures = buildCaptures(recorded.action.suggestedCaptures);
-    if (captures.length > 0) {
-      step.captures = captures;
+    lines.push("");
+    if (input.reviewResult.reviewedSteps.length > 0) {
+      lines.push("## Step Review Decisions");
+      lines.push("");
+      lines.push("| # | Keep | Risk | Confirmation | Removal Reason |");
+      lines.push("|---|------|------|-------------|----------------|");
+      for (const rs of input.reviewResult.reviewedSteps) {
+        const keep = rs.keep ? "Yes" : "No";
+        const risk = rs.riskLevel ?? "-";
+        const confirm = rs.requiresConfirmation ? `Yes: ${rs.confirmationReason ?? ""}` : "No";
+        const reason = rs.removalReason ?? "-";
+        lines.push(`| ${rs.originalOrdinal + 1} | ${keep} | ${risk} | ${confirm} | ${reason} |`);
+      }
+      lines.push("");
     }
-    if (recorded.action.action === "memory_append" && recorded.action.memoryCollection) {
-      step.memoryOperations = [{
-        type: "append",
-        collection: recorded.action.memoryCollection,
-        source: recorded.action.variableName ?? "extractedData"
-      }];
-    } else if (recorded.action.action === "memory_aggregate" && recorded.action.aggregation) {
-      const agg = recorded.action.aggregation;
-      step.memoryOperations = [{
-        type: "aggregate",
-        collection: agg.collection,
-        field: agg.field,
-        operation: agg.operation,
-        outputVariable: agg.outputVariable
-      }];
+    if (input.reviewResult.yamlContent) {
+      lines.push("## Generated YAML");
+      lines.push("");
+      lines.push("```yaml");
+      lines.push(input.reviewResult.yamlContent);
+      lines.push("```");
+      lines.push("");
     }
-    return step;
-  });
-  const baseUrl = new URL(startUrl).origin;
-  const runbook = {
-    title: goal,
-    settings: {
-      baseUrl,
-      defaultTimeout: 1e4,
-      pauseBetweenSteps: stepDelay,
-      stopOnError: true
-    },
-    metadata: {
-      startUrl,
-      goal,
-      goalAchieved,
-      totalSteps: filteredSteps.length,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      ...input.skills && input.skills.length > 0 && { skills: input.skills }
-    },
-    context: input.contextMarkdown
-  };
-  if (Object.keys(variables).length > 0) {
-    runbook.variables = variables;
-  }
-  runbook.steps = steps;
-  const allNotes = [];
-  if (humanGuidance && humanGuidance.length > 0) {
-    allNotes.push(
-      ...humanGuidance.map((g, i) => `[\u65B9\u91DD\u4FEE\u6B63 ${i + 1}] ${g}`)
-    );
-  }
-  if (interventions && interventions.length > 0) {
-    allNotes.push(
-      ...interventions.map(
-        (iv) => `[\u63A2\u7D22\u4E2D\u4ECB\u5165 \u30B9\u30C6\u30C3\u30D7#${iv.stepIndex}] ${iv.userInstruction}`
-      )
-    );
   }
-  if (allNotes.length > 0) {
-    runbook.notes = allNotes.join("\n");
+  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);
+  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));
   }
-  ParsedRunbookSchema.parse(runbook);
-  return stringify(runbook, { lineWidth: 120 });
-}
-function buildCaptures(suggested) {
-  if (!suggested || suggested.length === 0) return [];
-  return suggested.map((c) => ({
-    name: c.name,
-    strategy: c.strategy,
-    required: false,
-    ...c.description && { description: c.description },
-    ...c.pattern && { pattern: c.pattern },
-    ...c.group !== void 0 && c.group !== 1 && { group: c.group },
-    ...c.prompt && { prompt: c.prompt },
-    ...c.expression && { expression: c.expression }
-  }));
-}
-
-// src/runbook-generator/prompts.ts
-import { z as z3 } from "zod";
-var reviewResponseSchema = z3.object({
-  reviewedSteps: z3.array(z3.object({
-    originalOrdinal: z3.number(),
-    keep: z3.boolean(),
-    removalReason: z3.string().optional(),
-    riskLevel: z3.enum(["low", "medium", "high"]),
-    requiresConfirmation: z3.boolean(),
-    confirmationReason: z3.string().optional()
-  })),
-  summary: z3.string()
-});
-function createReviewPrompt(goal, recordedSteps, goalAchieved, interventions, locale) {
-  const system = getReviewSystemPrompt(locale);
-  const userPrompt = createReviewUserPrompt(goal, recordedSteps, goalAchieved, interventions, locale);
-  return { system, userPrompt };
+  return lines.join("\n");
 }
 
 export {
   explore,
-  buildRunbookYaml,
-  reviewResponseSchema,
-  createReviewPrompt
+  generateExplorationReport,
+  generateGenerationReportFile
 };
-//# sourceMappingURL=chunk-IGFCYKHC.js.map
+//# sourceMappingURL=chunk-CNJ5KCDN.js.map