explorbot 0.1.10 → 0.1.11

package/README.md

@@ -169,10 +169,36 @@ See [docs/commands.md](docs/commands.md) for all commands.
 
 | Output | Location | Description |
 |--------|----------|-------------|
-| Test files | `output/tests/*.js` | CodeceptJS tests you can run independently |
+| Test files | `output/tests/*.spec.ts` or `*.js` | Runnable Playwright or CodeceptJS tests |
 | Test plans | `output/plans/*.md` | Markdown documentation of scenarios |
 | Experience | `./experience/` | What Explorbot learned about your app |
 
+Every run is saved as a real Playwright or CodeceptJS test you can commit and run from CI. Choose the framework in your config:
+
+```js
+ai: { agents: { historian: { framework: 'playwright' } } }  // or 'codeceptjs' (default)
+```
+
+Playwright output uses the actual `page.locator(...)` calls executed during the run, with each action wrapped in `test.step` so failures land on a labelled step:
+
+```ts
+test('Create a new manual plan', async ({ page }) => {
+  await test.step("Click the 'New plan' button in toolbar", async () => {
+    await page.getByRole('button', { name: 'New plan' }).first().click();
+  });
+
+  await test.step('Select Manual plan type in modal', async () => {
+    await page.locator('#portal-container').getByRole('button', { name: 'Manual' }).click();
+  });
+
+  await test.step('Verification', async () => {
+    await expect(page).toContainText('Test Plan UI Creation 001');
+  });
+});
+```
+
+See [Automated Tests](docs/automated-tests.md) for the CodeceptJS version and how failed or unfinished scenarios are handled.
+
 ## Two Ways to Run
 
 **Interactive mode** — Launch TUI, guide exploration, get real-time feedback:

package/bin/explorbot-cli.ts

@@ -17,6 +17,7 @@ import { getCliName } from '../src/utils/cli-name.ts';
 import { log, setPreserveConsoleLogs } from '../src/utils/logger.js';
 import { jsonToTable } from '../src/utils/markdown-parser.js';
 import { parseMarkdownToTerminal } from '../src/utils/markdown-terminal.js';
+import { type NextStepSection, printNextSteps, relativeToCwd } from '../src/utils/next-steps.ts';
 
 const program = new Command();
 const cli = getCliName();
@@ -25,9 +26,10 @@ const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../p
 const pkgVersion = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version as string;
 
 program.name(cli).description('AI-powered web exploration tool').version(pkgVersion, '-V, --version');
-program.hook('preAction', () => {
+
+if (!process.env.EXPLORBOT_NO_BANNER) {
   console.log(`⛵ ${chalk.yellow.bold(`Explorbot v${pkgVersion}`)} ${chalk.dim('Autonomous Testing Agent')}`);
-});
+}
 
 interface CLIOptions {
   verbose?: boolean;
@@ -188,26 +190,32 @@ addCommonOptions(program.command('plan <path>').description('Generate test plan
       }
 
       const savedPath = explorBot.savePlan();
-      const planFile = savedPath ? path.basename(savedPath) : 'plan.md';
 
       const cliFlags = [options.path ? `--path ${options.path}` : '', options.session ? '--session' : ''].filter(Boolean).join(' ');
       const cliSuffix = cliFlags ? ` ${cliFlags}` : '';
 
-      const { PlanCommand } = await import('../src/commands/plan-command.js');
-      const planCommand = new PlanCommand(explorBot);
-      planCommand.suggestions = [
-        { command: `test ${planFile} 1${cliSuffix}`, hint: 'run first new test' },
-        { command: `test ${planFile} *${cliSuffix}`, hint: 'run all new tests' },
-      ];
-      if (suite && suite.automatedTestCount > 0) {
-        for (const f of suite.getAutomatedTestFiles()) {
-          planCommand.suggestions.push({
-            command: `rerun ${path.relative(process.cwd(), f)}${cliSuffix}`,
-            hint: 're-run automated tests',
-          });
-        }
+      const sections: NextStepSection[] = [];
+      if (savedPath) {
+        const relPlan = relativeToCwd(savedPath);
+        sections.push({
+          label: 'Plan',
+          path: savedPath,
+          commands: [
+            { label: 'Re-run', command: `${cli} test ${relPlan} 1${cliSuffix}` },
+            { label: 'Run all', command: `${cli} test ${relPlan} *${cliSuffix}` },
+            { label: 'Run range', command: `${cli} test ${relPlan} 1-3${cliSuffix}` },
+          ],
+        });
+      }
+      const automatedFiles = suite && suite.automatedTestCount > 0 ? suite.getAutomatedTestFiles() : [];
+      if (automatedFiles.length > 0) {
+        const commands = automatedFiles.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}${cliSuffix}` }));
+        sections.push({
+          label: `Automated tests (${automatedFiles.length})`,
+          commands,
+        });
       }
-      planCommand.printSuggestions();
+      printNextSteps(sections);
 
       await explorBot.stop();
       await showStatsAndExit(0);
@@ -387,7 +395,7 @@ program
 
 program
   .command('clean [target]')
-  .description('Clean files: states, research, plans, experiences, output (default: output + experiences)')
+  .description('Clean files: states, research, plans, tests, experiences, output (default: output + experiences)')
   .option('-p, --path <path>', 'Custom path to clean')
   .action(async (target, options) => {
     const customPath = options.path;
@@ -398,6 +406,7 @@ program
       states: { description: 'page states', dir: path.join(basePath, 'output', 'states') },
       research: { description: 'research cache', dir: path.join(basePath, 'output', 'research') },
       plans: { description: 'test plans', dir: path.join(basePath, 'output', 'plans') },
+      tests: { description: 'generated tests', dir: path.join(basePath, 'output', 'tests') },
       experiences: { description: 'experience files', dir: path.join(basePath, 'experience') },
       output: { description: 'all output files', dir: path.join(basePath, 'output') },
     };

package/dist/bin/explorbot-cli.js

@@ -17,14 +17,15 @@ import { getCliName } from "../src/utils/cli-name.js";
 import { log, setPreserveConsoleLogs } from '../src/utils/logger.js';
 import { jsonToTable } from '../src/utils/markdown-parser.js';
 import { parseMarkdownToTerminal } from '../src/utils/markdown-terminal.js';
+import { printNextSteps, relativeToCwd } from "../src/utils/next-steps.js";
 const program = new Command();
 const cli = getCliName();
 const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../package.json');
 const pkgVersion = JSON.parse(fs.readFileSync(pkgPath, 'utf-8')).version;
 program.name(cli).description('AI-powered web exploration tool').version(pkgVersion, '-V, --version');
-program.hook('preAction', () => {
+if (!process.env.EXPLORBOT_NO_BANNER) {
     console.log(`⛵ ${chalk.yellow.bold(`Explorbot v${pkgVersion}`)} ${chalk.dim('Autonomous Testing Agent')}`);
-});
+}
 function buildExplorBotOptions(from, options) {
     return {
         from,
@@ -155,24 +156,30 @@ addCommonOptions(program.command('plan <path>').description('Generate test plan
             }
         }
         const savedPath = explorBot.savePlan();
-        const planFile = savedPath ? path.basename(savedPath) : 'plan.md';
         const cliFlags = [options.path ? `--path ${options.path}` : '', options.session ? '--session' : ''].filter(Boolean).join(' ');
         const cliSuffix = cliFlags ? ` ${cliFlags}` : '';
-        const { PlanCommand } = await import('../src/commands/plan-command.js');
-        const planCommand = new PlanCommand(explorBot);
-        planCommand.suggestions = [
-            { command: `test ${planFile} 1${cliSuffix}`, hint: 'run first new test' },
-            { command: `test ${planFile} *${cliSuffix}`, hint: 'run all new tests' },
-        ];
-        if (suite && suite.automatedTestCount > 0) {
-            for (const f of suite.getAutomatedTestFiles()) {
-                planCommand.suggestions.push({
-                    command: `rerun ${path.relative(process.cwd(), f)}${cliSuffix}`,
-                    hint: 're-run automated tests',
-                });
-            }
+        const sections = [];
+        if (savedPath) {
+            const relPlan = relativeToCwd(savedPath);
+            sections.push({
+                label: 'Plan',
+                path: savedPath,
+                commands: [
+                    { label: 'Re-run', command: `${cli} test ${relPlan} 1${cliSuffix}` },
+                    { label: 'Run all', command: `${cli} test ${relPlan} *${cliSuffix}` },
+                    { label: 'Run range', command: `${cli} test ${relPlan} 1-3${cliSuffix}` },
+                ],
+            });
+        }
+        const automatedFiles = suite && suite.automatedTestCount > 0 ? suite.getAutomatedTestFiles() : [];
+        if (automatedFiles.length > 0) {
+            const commands = automatedFiles.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}${cliSuffix}` }));
+            sections.push({
+                label: `Automated tests (${automatedFiles.length})`,
+                commands,
+            });
         }
-        planCommand.printSuggestions();
+        printNextSteps(sections);
         await explorBot.stop();
         await showStatsAndExit(0);
     }
@@ -341,7 +348,7 @@ program
 });
 program
     .command('clean [target]')
-    .description('Clean files: states, research, plans, experiences, output (default: output + experiences)')
+    .description('Clean files: states, research, plans, tests, experiences, output (default: output + experiences)')
     .option('-p, --path <path>', 'Custom path to clean')
     .action(async (target, options) => {
     const customPath = options.path;
@@ -351,6 +358,7 @@ program
         states: { description: 'page states', dir: path.join(basePath, 'output', 'states') },
         research: { description: 'research cache', dir: path.join(basePath, 'output', 'research') },
         plans: { description: 'test plans', dir: path.join(basePath, 'output', 'plans') },
+        tests: { description: 'generated tests', dir: path.join(basePath, 'output', 'tests') },
         experiences: { description: 'experience files', dir: path.join(basePath, 'experience') },
         output: { description: 'all output files', dir: path.join(basePath, 'output') },
     };

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -83,7 +83,7 @@
     "axe-core": "^4.11.1",
     "bash-tool": "^1.3.15",
     "cli-highlight": "^2.1.11",
-    "codeceptjs": "4.0.0-rc.11",
+    "codeceptjs": "4.0.0-rc.16",
     "commander": "^14.0.1",
     "debug": "^4.4.3",
     "dedent": "^1.6.0",

package/dist/rules/navigator/output.md

@@ -13,6 +13,10 @@ In <explanation> write only one line without heading or bullet list or any other
 Check previous solutions, if there is already successful solution, use it!
 CodeceptJS code must start with "I."
 All lines of code must be CodeceptJS code and start with "I."
+
+Do not mix form filling with navigation in the same code block.
+If the code block fills a form and clicks a submit/confirm control, stop there — do not append I.amOnPage afterwards. Submitting the form already triggers navigation on the server side, and a follow-up I.amOnPage cancels that in-flight navigation and discards the just-submitted state (session, cookies, redirect target).
+If the action does not cause navigation on its own and a separate page visit is required to reach the target, put I.amOnPage in its own code block as a distinct step, not glued onto the form submission block.
 </rules>
 
 <output>
@@ -42,6 +46,11 @@ Use only locators from HTML PAGE that was passed in <page> context.
 <example_output>
 Trying to fill the form on the page
 
+```js
+  I.fillField({ "role": "textbox", "text": "Name" }, 'Value');
+  I.click({ "role": "button", "text": "Submit" });
+```
+
 ```js
   I.fillField('Name', 'Value');
   I.click('Submit');

package/dist/rules/navigator/verification-actions.md

@@ -113,6 +113,8 @@ For input field values, ALWAYS use I.seeInField() — never check value via CSS
 Prefer text locators (label, name, placeholder) for form fields: I.seeInField('Search', 'value') over I.seeInField('input[name="search"]', 'value').
 Only use locators that exist in the provided HTML or ARIA snapshot.
 Verify exact conditions, not approximate matches.
+NEVER use `:has-text(...)` inside a seeElement/dontSeeElement locator. Checking text inside an element is the job of I.see(text, context) — the `:has-text()` form duplicates that capability with a fragile selector.
+NEVER emit two assertions that check the same fact with different shapes. `I.see(text, locator)` and `I.seeElement("<locator>:has-text('text')")` verify the same thing — pick one (prefer I.see). One claim, one assertion.
 </verification_rules>
 
 [DO NEVER USE OTHER CODECEPTJS COMMANDS THAN PROPOSED HERE]

package/dist/src/action-result.js

@@ -502,7 +502,7 @@ export class ActionResult {
                 }
             }
             if (processedParts.length > 0) {
-                pageDiff.htmlParts = processedParts;
+                pageDiff.htmlParts = collapseHtmlParts(processedParts);
             }
         }
         if (pageDiff.ariaChanges && this.iframeSnapshots.length > 0) {
@@ -517,6 +517,28 @@ export class ActionResult {
         return result;
     }
 }
+const HTML_PARTS_TOTAL_BUDGET = 8000;
+const HTML_PARTS_COUNT_LIMIT = 8;
+const HTML_PART_SUBTREE_BUDGET = 2000;
+function collapseHtmlParts(parts) {
+    const total = parts.reduce((sum, p) => sum + p.subtree.length, 0);
+    const fullPageReRender = total > HTML_PARTS_TOTAL_BUDGET || parts.length > HTML_PARTS_COUNT_LIMIT;
+    if (fullPageReRender) {
+        return parts.map((part) => ({
+            ...part,
+            subtree: `<html><head></head><body>...collapsed (${part.subtree.length} chars, ${part.added.length} added, ${part.removed.length} removed)...</body></html>`,
+        }));
+    }
+    return parts.map((part) => {
+        if (part.subtree.length <= HTML_PART_SUBTREE_BUDGET)
+            return part;
+        const head = part.subtree.slice(0, HTML_PART_SUBTREE_BUDGET);
+        return {
+            ...part,
+            subtree: `${head}...<!-- truncated ${part.subtree.length - HTML_PART_SUBTREE_BUDGET} chars -->`,
+        };
+    });
+}
 export class Diff {
     current;
     previous;

package/dist/src/action.js

@@ -24,11 +24,15 @@ class Action {
     expectation = null;
     lastError = null;
     playwrightHelper;
-    constructor(actor, stateManager) {
+    playwrightGroupId = null;
+    assertionSteps = [];
+    recorder;
+    constructor(actor, stateManager, recorder) {
         this.actor = actor;
         this.stateManager = stateManager;
         this.config = ConfigParser.getInstance().getConfig();
         this.playwrightHelper = container.helpers('Playwright');
+        this.recorder = recorder;
     }
     async caputrePageWithScreenshot() {
         return this.capturePageState({ includeScreenshot: true });
@@ -57,7 +61,15 @@ class Action {
             const timestamp = Date.now();
             const page = this.playwrightHelper.page;
             const frame = this.playwrightHelper.frame;
-            const [html, title, browserLogs] = await Promise.all([this.actor.grabSource(), this.actor.grabTitle(), this.captureBrowserLogs()]);
+            await page?.waitForLoadState('domcontentloaded', { timeout: 10000 })?.catch(() => { });
+            const grabAll = () => Promise.all([this.actor.grabSource(), this.actor.grabTitle(), this.captureBrowserLogs()]);
+            const [html, title, browserLogs] = await grabAll().catch(async (err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (!/navigating and changing the content/i.test(msg))
+                    throw err;
+                await page?.waitForLoadState('domcontentloaded', { timeout: 10000 })?.catch(() => { });
+                return grabAll();
+            });
             const url = page?.url() || (await this.actor.grabCurrentUrl?.());
             let screenshotFile = undefined;
             if (includeScreenshot) {
@@ -183,7 +195,10 @@ class Action {
         setActivity('🔎 Browsing...', 'action');
         let codeString = code.replace(/^\(I\) => /, '').trim();
         const executedSteps = [];
-        registerStepLogger(executedSteps);
+        const assertionSteps = [];
+        const stepListener = attachStepLogger(executedSteps, assertionSteps);
+        const groupId = this.recorder ? await this.recorder.beginAction(codeString) : null;
+        this.playwrightGroupId = groupId;
         const activeSpan = Observability.getSpan();
         const tracer = trace.getTracer('ai');
         const stepSpan = activeSpan ? tracer.startSpan('codeceptjs.step', undefined, trace.setSpan(context.active(), activeSpan)) : null;
@@ -213,6 +228,7 @@ class Action {
             }
             this.stateManager.updateState(pageState, codeString);
             this.actionResult = pageState;
+            this.assertionSteps = assertionSteps;
         }
         catch (err) {
             debugLog('Action error', errorToString(err));
@@ -221,10 +237,13 @@ class Action {
                 await recorder.reset();
                 await recorder.start();
             }
+            this.assertionSteps = [];
             throw err;
         }
         finally {
-            unregisterStepLogger();
+            if (groupId)
+                await this.recorder.endAction();
+            detachStepLogger(stepListener);
             if (stepSpan) {
                 stepSpan.end();
             }
@@ -350,39 +369,28 @@ function hasPlaywrightCommands(code) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-let stepLoggerRegistered = false;
-let stepLoggerTarget = null;
-const stepLogger = (step, error) => {
-    if (!step?.toCode) {
-        return;
-    }
-    if (step.name?.startsWith('grab'))
-        return;
-    const stepCode = step.toCode();
-    if (stepLoggerTarget) {
-        stepLoggerTarget.push(stepCode);
-    }
-    if (error) {
-        tag('step').log(step, error);
-        return;
-    }
-    tag('step').log(step);
-};
-const registerStepLogger = (target) => {
-    stepLoggerTarget = target;
-    if (stepLoggerRegistered) {
-        return;
-    }
-    stepLoggerRegistered = true;
-    codeceptjs.event.dispatcher.on(codeceptjs.event.step.passed, stepLogger);
-    codeceptjs.event.dispatcher.on(codeceptjs.event.step.failed, stepLogger);
+const ASSERTION_STEP_NAMES = new Set(['see', 'dontSee', 'seeElement', 'dontSeeElement', 'seeInField', 'dontSeeInField', 'seeInCurrentUrl', 'dontSeeInCurrentUrl']);
+const attachStepLogger = (target, assertionsTarget) => {
+    const listener = (step, error) => {
+        if (!step?.toCode)
+            return;
+        if (step.name?.startsWith('grab'))
+            return;
+        target.push(step.toCode());
+        if (assertionsTarget && ASSERTION_STEP_NAMES.has(step.name)) {
+            assertionsTarget.push({ name: step.name, args: step.args || [] });
+        }
+        if (error) {
+            tag('step').log(step, error);
+            return;
+        }
+        tag('step').log(step);
+    };
+    codeceptjs.event.dispatcher.on(codeceptjs.event.step.passed, listener);
+    codeceptjs.event.dispatcher.on(codeceptjs.event.step.failed, listener);
+    return listener;
 };
-const unregisterStepLogger = () => {
-    stepLoggerTarget = null;
-    if (!stepLoggerRegistered) {
-        return;
-    }
-    stepLoggerRegistered = false;
-    codeceptjs.event.dispatcher.off(codeceptjs.event.step.passed, stepLogger);
-    codeceptjs.event.dispatcher.off(codeceptjs.event.step.failed, stepLogger);
+const detachStepLogger = (listener) => {
+    codeceptjs.event.dispatcher.off(codeceptjs.event.step.passed, listener);
+    codeceptjs.event.dispatcher.off(codeceptjs.event.step.failed, listener);
 };

package/dist/src/ai/bosun.js

@@ -6,8 +6,10 @@ import { setActivity } from "../activity.js";
 import { Observability } from "../observability.js";
 import { Plan, Task, Test, TestResult } from "../test-plan.js";
 import { HooksRunner } from "../utils/hooks-runner.js";
+import { getCliName } from "../utils/cli-name.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop, pause } from "../utils/loop.js";
+import { printNextSteps } from "../utils/next-steps.js";
 import { locatorRule } from "./rules.js";
 import { TaskAgent, isInteractive } from "./task-agent.js";
 import { createCodeceptJSTools } from "./tools.js";
@@ -391,7 +393,15 @@ export class Bosun extends TaskAgent {
         }
         const content = this.generateKnowledgeContent(state, successfulInteractions);
         const result = knowledgeTracker.addKnowledge(knowledgePath, content);
-        tag('success').log(`Knowledge saved to: ${result.filePath}`);
+        const cli = getCliName();
+        const sections = [
+            {
+                label: 'Knowledge',
+                path: result.filePath,
+                commands: [{ label: 'View matches', command: `${cli} knows ${knowledgePath}` }],
+            },
+        ];
+        printNextSteps(sections);
     }
     generateKnowledgeContent(state, interactions) {
         const lines = [];

package/dist/src/ai/conversation.js

@@ -1,6 +1,8 @@
 export function toolExecutionLabel(input) {
     return input?.explanation || input?.assertion || input?.reason || input?.request || '';
 }
+const AUTO_COMPACT_ARIA_CHANGES_CUTOFF = 500;
+const AUTO_COMPACT_TARGETED_HTML_CUTOFF = 500;
 export class Conversation {
     id;
     messages;
@@ -105,6 +107,43 @@ export class Conversation {
     autoTrimTag(tagName, maxLength) {
         this.autoTrimRules.set(tagName, maxLength);
     }
+    compactToolResults(keepLastN) {
+        const toolMessageIndexes = [];
+        for (let i = 0; i < this.messages.length; i++) {
+            if (this.messages[i].role === 'tool')
+                toolMessageIndexes.push(i);
+        }
+        const compactUpTo = toolMessageIndexes.length - Math.max(0, keepLastN);
+        for (let k = 0; k < compactUpTo; k++) {
+            const message = this.messages[toolMessageIndexes[k]];
+            if (!Array.isArray(message.content))
+                continue;
+            for (const part of message.content) {
+                if (part.type !== 'tool-result')
+                    continue;
+                const rawOutput = part.output;
+                if (!rawOutput || rawOutput.type !== 'json' || !rawOutput.value || typeof rawOutput.value !== 'object')
+                    continue;
+                const value = rawOutput.value;
+                if (value.pageDiff && typeof value.pageDiff === 'object') {
+                    const pageDiff = value.pageDiff;
+                    if (Array.isArray(pageDiff.htmlParts)) {
+                        pageDiff.htmlParts = undefined;
+                        pageDiff.compacted = true;
+                    }
+                    if (typeof pageDiff.ariaChanges === 'string' && pageDiff.ariaChanges.length > AUTO_COMPACT_ARIA_CHANGES_CUTOFF) {
+                        pageDiff.ariaChanges = `${pageDiff.ariaChanges.slice(0, AUTO_COMPACT_ARIA_CHANGES_CUTOFF)}...`;
+                    }
+                    if (typeof pageDiff.iframes === 'string') {
+                        pageDiff.iframes = undefined;
+                    }
+                }
+                if (typeof value.targetedHtml === 'string' && value.targetedHtml.length > AUTO_COMPACT_TARGETED_HTML_CUTOFF) {
+                    value.targetedHtml = `${value.targetedHtml.slice(0, AUTO_COMPACT_TARGETED_HTML_CUTOFF)}...`;
+                }
+            }
+        }
+    }
     hasTag(tagName, lastN) {
         const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const regex = new RegExp(`<${escapedTag}>`, 'g');

package/dist/src/ai/historian/codeceptjs.js

@@ -0,0 +1,109 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ActionResult } from "../../action-result.js";
+import { ConfigParser } from "../../config.js";
+import { KnowledgeTracker } from "../../knowledge-tracker.js";
+import { tag } from "../../utils/logger.js";
+import { relativeToCwd } from "../../utils/next-steps.js";
+import { ASSERTION_TOOLS, CODECEPT_TOOLS } from "../tools.js";
+import { escapeString, getExecutionLabel, isNonReusableCode, stripComments } from "./utils.js";
+export function WithCodeceptJS(Base) {
+    return class extends Base {
+        toCode(conversation, scenario) {
+            const toolExecutions = conversation.getToolExecutions();
+            const TRACKABLE_TOOLS = [...CODECEPT_TOOLS, ...ASSERTION_TOOLS];
+            const successfulSteps = toolExecutions.filter((exec) => exec.wasSuccessful && TRACKABLE_TOOLS.includes(exec.toolName) && exec.output?.code);
+            if (successfulSteps.length === 0) {
+                return '';
+            }
+            const lines = [];
+            lines.push(`Scenario('${escapeString(scenario)}', ({ I }) => {`);
+            for (const exec of successfulSteps) {
+                if (isNonReusableCode(exec.output.code))
+                    continue;
+                const explanation = getExecutionLabel(exec);
+                if (explanation) {
+                    lines.push('');
+                    lines.push(`  Section('${escapeString(explanation)}');`);
+                }
+                const code = stripComments(exec.output.code);
+                const codeLines = code.includes('\n') ? code.split('\n') : code.split('; ');
+                for (const codeLine of codeLines) {
+                    const trimmed = codeLine.trim();
+                    if (trimmed) {
+                        lines.push(`  ${trimmed}`);
+                    }
+                }
+            }
+            lines.push('});');
+            return lines.join('\n');
+        }
+        saveCodeceptPlanToFile(plan) {
+            const lines = [];
+            lines.push(`import step, { Section } from 'codeceptjs/steps';`);
+            lines.push('');
+            lines.push(`Feature('${escapeString(plan.title)}')`);
+            lines.push('');
+            const startUrl = plan.url || plan.tests[0]?.startUrl;
+            if (startUrl) {
+                lines.push('Before(({ I }) => {');
+                lines.push(`  I.amOnPage('${escapeString(startUrl)}');`);
+                lines.push(...this.getKnowledgeLines(startUrl));
+                lines.push('});');
+                lines.push('');
+            }
+            for (const test of plan.tests) {
+                if (test.generatedCode) {
+                    if (test.isSuccessful) {
+                        lines.push(test.generatedCode);
+                    }
+                    else {
+                        lines.push(`// FAILED: ${test.scenario}`);
+                        lines.push(test.generatedCode.replace(/Scenario\(/, 'Scenario.skip('));
+                    }
+                    lines.push('');
+                    continue;
+                }
+                lines.push(`Scenario.todo('${escapeString(test.scenario)}', ({ I }) => {`);
+                if (test.plannedSteps.length > 0) {
+                    for (const step of test.plannedSteps) {
+                        lines.push(`  // ${step}`);
+                    }
+                }
+                else {
+                    lines.push(`  // ${test.scenario}`);
+                }
+                lines.push('});');
+                lines.push('');
+            }
+            const testsDir = ConfigParser.getInstance().getTestsDir();
+            mkdirSync(testsDir, { recursive: true });
+            const filename = plan.title.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+            const filePath = join(testsDir, `${filename}.js`);
+            writeFileSync(filePath, lines.join('\n'));
+            this.savedFiles.add(filePath);
+            tag('substep').log(`Saved plan tests to: ${relativeToCwd(filePath)}`);
+            return filePath;
+        }
+        getKnowledgeLines(url, indent = '  ') {
+            const knowledgeTracker = new KnowledgeTracker();
+            const state = new ActionResult({ url });
+            const { wait, waitForElement, code } = knowledgeTracker.getStateParameters(state, ['wait', 'waitForElement', 'code']);
+            const lines = [];
+            if (wait !== undefined) {
+                lines.push(`${indent}I.wait(${wait});`);
+            }
+            if (waitForElement) {
+                lines.push(`${indent}I.waitForElement(${JSON.stringify(waitForElement)});`);
+            }
+            if (code) {
+                for (const codeLine of code.split('\n')) {
+                    const trimmed = codeLine.trim();
+                    if (trimmed)
+                        lines.push(`${indent}${trimmed}`);
+                }
+            }
+            return lines;
+        }
+    };
+}