explorbot 0.1.10 → 0.1.11

package/dist/src/ai/rules.js

@@ -161,6 +161,20 @@ export const focusedElementRule = dedent `
   If focus is on wrong element, click the correct field first.
   </focused_element_actions>
 `;
+export const unexpectedPopupRule = dedent `
+  <unexpected_popup_rule>
+  If a modal/popup appeared that you didn't expect, dismiss it first before continuing with original task.
+  If elements become hidden or unclickable (timeout errors on visible elements), a dialog or overlay may have appeared on top.
+  If a click error mentions "intercepts pointer events", another element is covering the target — dismiss it first.
+  If buttons are disabled unexpectedly, check if a popup is blocking interaction or if required form fields are empty.
+
+  Dismiss strategy (try in order):
+  1. I.clickXY(0, 0) — click outside the popup to close it
+  2. I.pressKey('Escape') — press Escape to dismiss
+  3. I.click('Cancel') — click Cancel button if present
+  4. I.click({ role: 'button', text: 'Close' }) — click X/close button if present
+  </unexpected_popup_rule>
+`;
 export const sectionContextRule = dedent `
   <section_context_rule>
   Context parameter is DEFAULT for all interactions. ALWAYS use container from UI map sections unless locator is XPath or unique ID.
@@ -186,17 +200,7 @@ export const sectionContextRule = dedent `
   - Locator is a unique ID (#specific-element)
   </section_context_rule>
 
-  <unexpected_popup_rule>
-  If a modal/popup appeared that you didn't expect, dismiss it first before continuing with original task.
-  If elements become hidden or unclickable (timeout errors on visible elements), a dialog or overlay may have appeared on top.
-  If buttons are disabled unexpectedly, check if a popup is blocking interaction or if required form fields are empty.
-
-  Dismiss strategy (try in order):
-  1. I.clickXY(0, 0) — click outside the popup to close it
-  2. I.pressKey('Escape') — press Escape to dismiss
-  3. I.click('Cancel') — click Cancel button if present
-  4. I.click({ role: 'button', text: 'Close' }) — click X/close button if present
-  </unexpected_popup_rule>
+  ${unexpectedPopupRule}
 `;
 export function multipleTabsRule(tabs) {
     const tabsList = tabs.map((tab, i) => `  ${i + 1}. ${tab.title} - ${tab.url}`).join('\n');
@@ -265,12 +269,19 @@ export const actionRule = dedent `
     I.fillField('Username', 'John', '.login-form'); // fills Username inside .login-form
     I.fillField('Username', 'John'); // fills the field located by name or placeholder or label "Username" with the text "John"
     I.fillField('//user/input', 'John'); // fills the field located by XPath "//user/input" with the text "John"
-  </example>  
+    I.fillField('Description', 'Hello world', '.editor'); // works for rich text / code editors too
+  </example>
+
+  I.fillField handles plain inputs, textareas, contenteditable regions, and rich text / code editors
+  (Monaco, ProseMirror, CodeMirror, TipTap, Quill, Draft.js, Slate, etc.) transparently.
+  ALWAYS use I.fillField for rich editors — target the editor container or its nearest label/heading with a normal locator.
+  Do NOT open the editor with raw JS (executeScript, page.evaluate), do NOT dispatch synthetic events,
+  do NOT call the editor's own API (monaco.editor.setValue, view.dispatch, etc.) to write text.
 
   ### I.type
 
-  Types text into the currently focused element. Use when fillField doesn't work,
-  for instance, for highly customized input fields like Monaco editors or rich text editors.
+  Types text into the currently focused element. Use only when there is no locator you can pass to I.fillField —
+  e.g. the target is implicit (a just-opened command palette, an autocomplete that steals focus, a canvas-based surface).
 
   I.type(<text>)
 
@@ -282,6 +293,7 @@ export const actionRule = dedent `
   DOES NOT receive any locator, just text to type.
   NEVER write: I.type('text', locator) or I.type('text', {locator: '...'}) — this is INVALID.
   To type into a specific field: use I.fillField(locator, text) or I.click(locator) then I.type(text).
+  Do NOT reach for I.type just because the target looks like a rich editor — I.fillField handles those.
 
   ### I.pressKey
 

package/dist/src/ai/tester.js

@@ -6,9 +6,11 @@ import { z } from 'zod';
 import { ActionResult } from "../action-result.js";
 import { setActivity } from "../activity.js";
 import { ConfigParser } from "../config.js";
+import { Observability } from "../observability.js";
 import { Stats } from "../stats.js";
 import { TestResult } from "../test-plan.js";
 import { detectFocusArea, extractFocusedElement } from "../utils/aria.js";
+import { ErrorPageError } from "../utils/error-page.js";
 import { HooksRunner } from "../utils/hooks-runner.js";
 import { createDebug, tag } from "../utils/logger.js";
 import { loop } from "../utils/loop.js";
@@ -121,10 +123,34 @@ export class Tester extends TaskAgent {
         // Note: Markdown saving functionality removed from Conversation class
         const initialPrompt = await this.buildTestPrompt(task, initialState);
         conversation.addUserText(initialPrompt);
+        return await Observability.run(`test: ${task.scenario}`, {
+            sessionId: task.sessionName,
+            tags: ['tester'],
+            input: {
+                scenario: task.scenario,
+                startUrl: task.startUrl,
+                expected: task.expected,
+            },
+        }, async () => this.runTestSession(task, initialState, conversation, { offFailedRequest, page, onPageError, onConsoleMessage }));
+    }
+    async runTestSession(task, initialState, conversation, handlers) {
+        const { offFailedRequest, page, onPageError, onConsoleMessage } = handlers;
         if (this.pilot) {
-            const plan = await this.pilot.planTest(task, initialState);
-            if (plan) {
-                conversation.addUserText(`Pilot's test plan:\n${plan}\n\nFollow this plan while executing the test.`);
+            try {
+                const plan = await this.pilot.planTest(task, initialState);
+                if (plan) {
+                    conversation.addUserText(`Pilot's test plan:\n${plan}\n\nFollow this plan while executing the test.`);
+                }
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                tag('error').log(`Pilot planning failed: ${message}`);
+                task.addNote(`Planning failed: ${message}`, TestResult.FAILED);
+                task.finish(TestResult.FAILED);
+                offFailedRequest?.();
+                page?.off('pageerror', onPageError);
+                page?.off('console', onConsoleMessage);
+                return { success: false };
             }
         }
         debugLog('Starting test execution with tools');
@@ -135,6 +161,8 @@ export class Tester extends TaskAgent {
         const currentUrl = this.explorer.getStateManager().getCurrentState()?.url || task.startUrl || '';
         await this.hooksRunner.runBeforeHook('tester', currentUrl);
         const offStateChange = this.explorer.getStateManager().onStateChange((event) => {
+            if (task.hasFinished)
+                return;
             if (event.toState?.url === event.fromState?.url)
                 return;
             task.addNote(`Navigated to ${event.toState?.url}`, TestResult.PASSED);
@@ -178,6 +206,10 @@ export class Tester extends TaskAgent {
                 conversation.cleanupTag('page_aria', '...cleaned aria snapshot...', 2);
                 conversation.cleanupTag('page_html', '...cleaned HTML snapshot...', 1);
                 conversation.cleanupTag('experience', '...cleaned experience...', 1);
+                conversation.cleanupTag('applied_experience', '...cleaned past experience...', 1);
+                conversation.cleanupTag('page_ui_map', '...cleaned UI map...', 1);
+                conversation.cleanupTag('page_ui_map_overlay', '...cleaned UI overlay...', 1);
+                conversation.compactToolResults(3);
                 if (iteration > 1) {
                     const isNewPage = this.previousUrl !== null && this.previousUrl !== currentState.url;
                     let nextStep = '';
@@ -199,6 +231,7 @@ export class Tester extends TaskAgent {
                 const result = await this.provider.invokeConversation(conversation, tools, {
                     maxToolRoundtrips: 5,
                     toolChoice: 'required',
+                    stopWhen: () => task.hasFinished,
                 });
                 if (!result)
                     throw new Error('Failed to get response from provider');
@@ -273,34 +306,30 @@ export class Tester extends TaskAgent {
                         context.setUserInput(result.message);
                     }
                     : undefined,
-                observability: {
-                    name: `test: ${task.scenario}`,
-                    agent: 'tester',
-                    sessionId: task.sessionName,
-                    metadata: {
-                        input: {
-                            scenario: task.scenario,
-                            startUrl: task.startUrl,
-                            expected: task.expected,
-                        },
-                    },
-                },
                 catch: async ({ error, stop }) => {
                     tag('error').log(`Test execution error: ${error}`);
-                    task.addNote(`Execution error: ${error instanceof Error ? error.message : String(error)}`);
+                    if (!task.hasFinished) {
+                        task.addNote(`Execution error: ${error instanceof Error ? error.message : String(error)}`);
+                    }
                     stop();
                 },
             });
             if (task.hasFinished)
                 break;
             const finalState = this.getCurrentState();
-            const wantsContinue = await this.pilot.finalReview(task, finalState, conversation);
+            const wantsContinue = await this.pilot.finalReview(task, finalState, conversation, this.navigator);
             if (!wantsContinue || task.hasFinished)
                 break;
             if (extensions >= this.MAX_EXTENSIONS)
                 break;
             extensions++;
             tag('info').log(`Pilot extending test (${extensions}/${this.MAX_EXTENSIONS})`);
+            conversation.cleanupTag('page_aria', '...trimmed...', 1);
+            conversation.cleanupTag('page_html', '...trimmed...', 0);
+            conversation.cleanupTag('experience', '...trimmed...', 0);
+            conversation.cleanupTag('page_ui_map', '...trimmed...', 0);
+            conversation.cleanupTag('page_ui_map_overlay', '...trimmed...', 0);
+            conversation.compactToolResults(1);
             shouldContinue = true;
         }
         const finalUrl = this.explorer.getStateManager().getCurrentState()?.url || currentUrl;
@@ -391,7 +420,15 @@ export class Tester extends TaskAgent {
             this.explorer.clearOtherTabsInfo();
         }
         if (isNewUrl) {
-            const research = await this.researcher.research(currentState);
+            let research = '';
+            try {
+                research = await this.researcher.research(currentState);
+            }
+            catch (err) {
+                if (!(err instanceof ErrorPageError))
+                    throw err;
+                tag('warning').log(`Research skipped: ${err.message}`);
+            }
             this.pageStateHash = currentStateHash;
             this.pageActionResult = currentState;
             let uiMapSection = '';
@@ -562,7 +599,7 @@ export class Tester extends TaskAgent {
     - Use finish() to complete the test, not record(). record() is for intermediate notes.
     - Call finish(verify) when all goals are achieved — provide an assertion to verify
     - ONLY call stop() if the scenario itself is completely irrelevant to this page and no expectations can be achieved
-    - Use reset() to navigate back to the initial page if needed. Do not call it if you are already on the initial page
+    - Use reset() ONLY as a last resort when the current page cannot host the scenario. Never reset after a successful flow just because an assertion or milestone did not match — verify differently or record() the finding instead. Reset is destructive and does not undo server-side side effects.
     - Be precise with locators (CSS or XPath)
     - Each click/type call returns the new page state automatically
     - Check for success messages from tool calls to verify if expected outcomes are achieved
@@ -678,13 +715,25 @@ export class Tester extends TaskAgent {
         return {
             reset: tool({
                 description: dedent `
-          Reset the testing flow by navigating back to the original page.
-          Use this when navigated too far from the desired state and
-          there's no clear path to achieve the expected result. This restarts the
-          testing flow from a known good state.
+          Navigate back to the start URL and discard progress in this iteration.
+          Reset is a LAST RESORT. It is destructive — any side effects already produced on the
+          server (records created, forms submitted) persist and cannot be undone by resetting.
+
+          Use reset ONLY for:
+          - navigation dead-ends where the current page cannot host the scenario
+          - irrecoverable errors that leave no actionable path forward
+
+          Do NOT use reset when:
+          - the previous action already succeeded (URL changed, record visible, confirmation shown)
+            and an assertion did not match — verify differently, record(), or finish() instead
+          - an expectation/milestone does not match app behavior but the flow worked — the work is
+            done; resetting just creates duplicates
+          - you want to "try again" after submitting a form — submitting again creates a duplicate
+
+          Pilot will review every reset and may veto it.
         `,
                 inputSchema: z.object({
-                    reason: z.string().optional().describe('Explanation why you need to navigate'),
+                    reason: z.string().optional().describe('Explanation why reset is the only option'),
                 }),
                 execute: async ({ reason }) => {
                     if (this.getCurrentState().isInsideIframe) {
@@ -698,6 +747,18 @@ export class Tester extends TaskAgent {
                             action: 'reset',
                         };
                     }
+                    task.resetCount += 1;
+                    if (this.pilot) {
+                        const currentStateForReview = this.getCurrentState();
+                        const allowed = await this.pilot.reviewReset(task, currentStateForReview, reason ?? '', conversation);
+                        if (!allowed) {
+                            return {
+                                success: false,
+                                action: 'reset',
+                                message: 'Reset rejected by Pilot; Continue execution',
+                            };
+                        }
+                    }
                     const explanation = reason ? `${reason} (RESET)` : 'Resetting to initial page';
                     const targetUrl = resetUrl;
                     task.addNote(explanation);
@@ -776,10 +837,13 @@ export class Tester extends TaskAgent {
                     verify: z.string().describe('Specific assertion to verify on the page before finishing (e.g., "New item appears in the list")'),
                 }),
                 execute: async ({ verify }) => {
+                    if (task.hasFinished) {
+                        return { success: true, action: 'finish', message: 'already finished' };
+                    }
                     task.addNote(`Finish requested: ${verify}`);
                     if (this.pilot) {
                         const currentState = this.getCurrentState();
-                        await this.pilot.reviewFinish(task, currentState, conversation);
+                        await this.pilot.reviewFinish(task, currentState, conversation, this.navigator);
                         if (!task.hasFinished) {
                             return {
                                 success: false,
@@ -852,7 +916,7 @@ export class Tester extends TaskAgent {
                     if (input.status !== null && task.isComplete()) {
                         if (this.pilot) {
                             const currentState = this.getCurrentState();
-                            await this.pilot.reviewCompletion(task, currentState, conversation);
+                            await this.pilot.reviewCompletion(task, currentState, conversation, this.navigator);
                         }
                         else {
                             const hasPassed = task.hasAchievedAny();

package/dist/src/ai/tools.js

@@ -84,7 +84,7 @@ export function createCodeceptJSTools(explorer, task) {
                             activeNote.screenshot = await action.saveScreenshot();
                         }
                         activeNote.commit(TestResult.PASSED);
-                        return successToolResult('click', { ...toolResult, attempts, code: command });
+                        return successToolResult('click', { ...toolResult, attempts, code: command }, action);
                     }
                 }
                 let disambiguated = null;
@@ -109,7 +109,7 @@ export function createCodeceptJSTools(explorer, task) {
                             activeNote.screenshot = await action.saveScreenshot();
                         }
                         activeNote.commit(TestResult.PASSED);
-                        return successToolResult('click', { ...toolResult, attempts, code: retryCmd, disambiguated: true });
+                        return successToolResult('click', { ...toolResult, attempts, code: retryCmd, disambiguated: true }, action);
                     }
                 }
                 const toolResult = await ActionResult.fromState(stateManager.getCurrentState()).toToolResult(previousState, commands[0]);
@@ -183,7 +183,7 @@ export function createCodeceptJSTools(explorer, task) {
                                 message: `Automatically used type() for "${key}" (not a standard key press)`,
                                 code: typeCommand,
                                 fallback: true,
-                            });
+                            }, action);
                         }
                         const errorMsg = `pressKey fallback to type() failed: ${action.lastError?.toString()}`;
                         if (toolResult?.pageDiff?.ariaChanges || toolResult?.pageDiff?.urlChanged) {
@@ -229,7 +229,7 @@ export function createCodeceptJSTools(explorer, task) {
                             ...toolResult,
                             message: `Pressed key: ${key}${modifier ? ` with modifier(s): ${Array.isArray(modifier) ? modifier.join('+') : modifier}` : ''}`,
                             code: pressKeyCommand,
-                        });
+                        }, action);
                     }
                     const errorMsg = `pressKey() failed: ${action.lastError?.toString()}`;
                     if (toolResult?.pageDiff?.ariaChanges || toolResult?.pageDiff?.urlChanged) {
@@ -338,7 +338,7 @@ export function createCodeceptJSTools(explorer, task) {
                         commandsExecuted: lines.length,
                         code: codeBlock,
                         suggestion: 'Verify the form was filled in correctly using see() tool. If needed to submit: try click() tool or form() with I.pressKey("Enter").',
-                    });
+                    }, action);
                 }
                 catch (error) {
                     activeNote.commit(TestResult.FAILED);
@@ -511,7 +511,7 @@ export function createAgentTools({ explorer, researcher, navigator, experienceTr
                         return successToolResult('verify', {
                             message: `Verification passed: ${assertion}`,
                             code: result.successfulCodes.join('\n'),
-                        });
+                        }, { assertionSteps: result.assertionSteps });
                     }
                     return failedToolResult('verify', `Verification failed: ${assertion}`, {
                         suggestion: 'The assertion could not be verified. Check if the condition is actually present on the page or try a different assertion.',
@@ -886,8 +886,14 @@ function countAriaChanges(ariaChanges) {
     const removedCount = removedMatch ? Number.parseInt(removedMatch[1]) : 0;
     return addedCount + removedCount;
 }
-function successToolResult(action, data) {
+function successToolResult(action, data, source) {
     const result = { success: true, action, ...data };
+    if (source?.playwrightGroupId) {
+        result.playwrightGroupId = source.playwrightGroupId;
+    }
+    if (source?.assertionSteps?.length) {
+        result.assertionSteps = source.assertionSteps;
+    }
     if (data?.pageDiff) {
         let suggestion = PAGE_DIFF_SUGGESTION;
         const ariaChanges = data.pageDiff.ariaChanges || '';

package/dist/src/browser-server.js

@@ -2,7 +2,9 @@ import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from '
 import path from 'node:path';
 import { chromium, firefox, webkit } from 'playwright-core';
 import { ConfigParser } from './config.js';
-import { log, tag } from './utils/logger.js';
+import { getCliName } from "./utils/cli-name.js";
+import { log } from './utils/logger.js';
+import { printNextSteps } from "./utils/next-steps.js";
 const ENDPOINT_FILENAME = '.browser-endpoint';
 function getEndpointFilePath() {
     const configParser = ConfigParser.getInstance();
@@ -50,8 +52,19 @@ async function launchServer(opts) {
     const wsEndpoint = server.wsEndpoint();
     writeEndpoint(wsEndpoint);
     log(`Browser server started: ${browserName} (${opts.show ? 'headed' : 'headless'})`);
-    tag('info').log(`WebSocket endpoint: ${wsEndpoint}`);
-    tag('info').log(`Endpoint saved to: ${getEndpointFilePath()}`);
+    const cli = getCliName();
+    const sections = [
+        {
+            label: 'Browser server',
+            path: getEndpointFilePath(),
+            commands: [
+                { label: 'Endpoint', command: wsEndpoint },
+                { label: 'Status', command: `${cli} browser status` },
+                { label: 'Stop', command: `${cli} browser stop` },
+            ],
+        },
+    ];
+    printNextSteps(sections);
     return server;
 }
 async function getAliveEndpoint() {

package/dist/src/commands/add-rule-command.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { render } from 'ink';
 import React from 'react';
 import { tag } from '../utils/logger.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { BaseCommand } from './base-command.js';
 export class AddRuleCommand extends BaseCommand {
     name = 'add-rule';
@@ -33,18 +34,20 @@ export class AddRuleCommand extends BaseCommand {
         mkdirSync(rulesDir, { recursive: true });
         const filePath = join(rulesDir, `${ruleName}.md`);
         if (existsSync(filePath)) {
-            tag('warning').log(`Rule file already exists: ${filePath}`);
+            tag('warning').log(`Rule file already exists: ${relativeToCwd(filePath)}`);
             return null;
         }
         const content = opts?.content || `Instructions for ${agentName} agent.`;
         writeFileSync(filePath, `${content.trim()}\n`);
-        tag('success').log(`Rule created: ${filePath}`);
-        if (opts?.urlPattern) {
-            tag('info').log(`Add to config: ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]`);
-        }
-        else {
-            tag('info').log(`Add to config: ai.agents.${agentName}.rules: ['${ruleName}']`);
-        }
+        const configLine = opts?.urlPattern ? `ai.agents.${agentName}.rules: [{ '${opts.urlPattern}': '${ruleName}' }]` : `ai.agents.${agentName}.rules: ['${ruleName}']`;
+        const sections = [
+            {
+                label: 'Rule',
+                path: filePath,
+                commands: [{ label: 'Add to config', command: configLine }],
+            },
+        ];
+        printNextSteps(sections);
         return filePath;
     }
 }

package/dist/src/commands/clean-command.js

@@ -7,6 +7,7 @@ export const CLEAN_TARGETS = {
     states: { description: 'page states', getDir: () => outputPath('states') },
     research: { description: 'research cache', getDir: () => outputPath('research') },
     plans: { description: 'test plans', getDir: () => outputPath('plans') },
+    tests: { description: 'generated tests', getDir: () => outputPath('tests') },
     experiences: { description: 'experience files', getDir: () => getExperienceDir() },
     output: { description: 'all output files', getDir: () => outputPath() },
 };
@@ -38,7 +39,7 @@ function cleanDirectoryContents(dirPath) {
 }
 export class CleanCommand extends BaseCommand {
     name = 'clean';
-    description = 'Clean files: clean [states|research|plans|experiences|output]';
+    description = 'Clean files: clean [states|research|plans|tests|experiences|output]';
     suggestions = Object.entries(CLEAN_TARGETS).map(([name, target]) => ({ command: `clean ${name}`, hint: `clean ${target.description}` }));
     async execute(args) {
         const target = args.trim().toLowerCase();

package/dist/src/commands/explore-command.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import figureSet from 'figures';
 import { getStyles } from '../ai/planner/styles.js';
 import { Stats } from '../stats.js';
@@ -6,6 +5,7 @@ import { getCliName } from "../utils/cli-name.js";
 import { ErrorPageError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
 import { jsonToTable } from '../utils/markdown-parser.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { BaseCommand } from './base-command.js';
 export class ExploreCommand extends BaseCommand {
     name = 'explore';
@@ -65,8 +65,8 @@ export class ExploreCommand extends BaseCommand {
         if (mainUrl)
             await this.explorBot.visit(mainUrl);
         const savedPath = this.explorBot.savePlans(this.completedPlans);
-        this.printResults(savedPath);
-        this.printRerunSuggestions();
+        this.printResults();
+        this.printNextSteps(savedPath);
     }
     async runAllStyles(pageUrl, feature, parentPlan, completedPlans) {
         let fresh = true;
@@ -97,7 +97,7 @@ export class ExploreCommand extends BaseCommand {
             tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
         }
     }
-    printResults(savedPath) {
+    printResults() {
         const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
         if (allTests.length === 0)
             return;
@@ -128,20 +128,32 @@ export class ExploreCommand extends BaseCommand {
             columns.push('Plan');
         tag('multiline').log(jsonToTable(rows, columns));
         tag('info').log(`${figureSet.tick} ${allTests.length} tests completed`);
-        if (savedPath) {
-            const relativePath = path.relative(process.cwd(), savedPath);
-            tag('info').log(`Re-run tests: ${getCliName()} test ${relativePath} <index>`);
-        }
     }
-    printRerunSuggestions() {
+    printNextSteps(savedPlanPath) {
+        const cli = getCliName();
+        const sections = [];
+        if (savedPlanPath) {
+            const relPlan = relativeToCwd(savedPlanPath);
+            sections.push({
+                label: 'Plan',
+                path: savedPlanPath,
+                commands: [
+                    { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+                    { label: 'Run all', command: `${cli} test ${relPlan} *` },
+                    { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+                ],
+            });
+        }
         const savedFiles = this.explorBot.agentHistorian().getSavedFiles();
-        if (savedFiles.length === 0)
-            return;
-        for (const filePath of savedFiles) {
-            tag('info').log(`Generated: ${path.basename(filePath)}`);
+        if (savedFiles.length > 0) {
+            const commands = savedFiles.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+            commands.push({ label: 'List tests', command: `${cli} runs` });
+            sections.push({
+                label: `Generated tests (${savedFiles.length})`,
+                commands,
+            });
         }
-        tag('info').log(`List tests: ${getCliName()} runs`);
-        tag('info').log(`Re-run with healing: ${getCliName()} rerun <filename> [index]`);
+        printNextSteps(sections);
     }
     isLimitReached() {
         return this.maxTests != null && this.testsRun >= this.maxTests;

package/dist/src/commands/init-command.js

@@ -4,6 +4,7 @@ import chalk from 'chalk';
 import dedent from 'dedent';
 import { getCliName } from "../utils/cli-name.js";
 import { log, tag } from '../utils/logger.js';
+import { relativeToCwd } from "../utils/next-steps.js";
 const DEFAULT_CONFIG_TEMPLATE = `import { createOpenRouter } from '@openrouter/ai-sdk-provider';
 // import { '<your provider here>' } from '<your provider package here>';
 
@@ -57,10 +58,10 @@ export function runInitCommand(options) {
         const dir = resolve(customPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
-            log(`Created directory: ${dir}`);
+            log(`Created directory: ${relativeToCwd(dir)}`);
         }
         process.chdir(dir);
-        log(`Working in directory: ${dir}`);
+        log(`Working in directory: ${relativeToCwd(dir)}`);
     }
     try {
         let outPath = resolve(configPath);
@@ -73,22 +74,22 @@ export function runInitCommand(options) {
         const dir = dirname(outPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
-            log(`Created directory: ${dir}`);
+            log(`Created directory: ${relativeToCwd(dir)}`);
         }
         if (existsSync(outPath) && !force) {
-            log(`Config file already exists: ${outPath}`);
+            log(`Config file already exists: ${relativeToCwd(outPath)}`);
             log('Use --force to overwrite existing file');
             process.exit(1);
         }
         writeFileSync(outPath, DEFAULT_CONFIG_TEMPLATE, 'utf8');
-        log(`Created config file: ${outPath}`);
+        log(`Created config file: ${relativeToCwd(outPath)}`);
         const envPath = resolve(process.cwd(), '.env');
         if (!existsSync(envPath)) {
             writeFileSync(envPath, `${DEFAULT_ENV_TEMPLATE}\n`, 'utf8');
-            log(`Created env file: ${envPath}`);
+            log(`Created env file: ${relativeToCwd(envPath)}`);
         }
         else {
-            log(`Env file already exists: ${envPath}`);
+            log(`Env file already exists: ${relativeToCwd(envPath)}`);
         }
         log('');
         log('Next steps:');
@@ -102,7 +103,7 @@ export function runInitCommand(options) {
         tag('substep').log(chalk.yellow(`${getCliName()} start /dashboard`));
         if (!existsSync('./output')) {
             mkdirSync('./output', { recursive: true });
-            log('Created directory: ./output');
+            log('Created directory: output');
         }
     }
     catch (error) {

package/dist/src/commands/plan-command.js

@@ -1,7 +1,9 @@
 import path from 'node:path';
 import chalk from 'chalk';
 import figureSet from 'figures';
+import { getCliName } from "../utils/cli-name.js";
 import { tag } from '../utils/logger.js';
+import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { BaseCommand } from './base-command.js';
 export class PlanCommand extends BaseCommand {
     name = 'plan';
@@ -34,6 +36,36 @@ export class PlanCommand extends BaseCommand {
         }
         this.printPlanSummary();
         this.updateSuggestions();
+        this.printNextSteps();
+    }
+    printNextSteps() {
+        const savedPath = this.explorBot.lastSavedPlanPath;
+        if (!savedPath)
+            return;
+        const cli = getCliName();
+        const relPlan = relativeToCwd(savedPath);
+        const sections = [
+            {
+                label: 'Plan',
+                path: savedPath,
+                commands: [
+                    { label: 'Re-run', command: `${cli} test ${relPlan} 1` },
+                    { label: 'Run all', command: `${cli} test ${relPlan} *` },
+                    { label: 'Run range', command: `${cli} test ${relPlan} 1-3` },
+                    { label: 'Reload', command: `/plan:load ${relPlan}` },
+                ],
+            },
+        ];
+        const suite = this.explorBot.getSuite();
+        const files = suite && suite.automatedTestCount > 0 ? suite.getAutomatedTestFiles() : [];
+        if (files.length > 0) {
+            const commands = files.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}` }));
+            sections.push({
+                label: `Automated tests (${files.length})`,
+                commands,
+            });
+        }
+        printNextSteps(sections);
     }
     printPlanSummary() {
         const suite = this.explorBot.getSuite();