explorbot 0.5.10 → 0.6.0

package/dist/src/ai/tools.js

@@ -51,8 +51,8 @@ export function createCodeceptJSTools({ explorer, stateManager, judge }, task) {
           Never mix different elements — use separate click() calls instead.
           REQUIRED: include at least one command WITHOUT a container — a wrong or stale container always fails.
           Order by reliability:
-          1. I.click(text, container) - when the container is verified - e.g. I.click("Save", ".modal")
-          2. I.click(ARIA, container) - e.g. I.click({"role":"button","text":"Save"}, ".modal")
+          1. I.click(ARIA, container) - e.g. I.click({"role":"button","text":"Save"}, ".modal")
+          2. I.click(text, container) - when the container is verified - e.g. I.click("Save", ".modal")
           3. I.click(CSS, container) - e.g. I.click("#btn", ".modal")
           4. I.click(CSS) or I.click(XPath) - when locator already includes context (ID, XPath)
           After a result reporting multiple matches, reuse that locator with step.opts({ elementIndex: N }) as the last argument.
@@ -251,7 +251,7 @@ export function createCodeceptJSTools({ explorer, stateManager, judge }, task) {
                     const normalizedKey = key.toLowerCase();
                     const matchingStandardKey = Array.from(standardKeys).find((sk) => sk.toLowerCase() === normalizedKey);
                     const isStandardKey = !!matchingStandardKey;
-                    const keyToUse = matchingStandardKey || key;
+                    const keyToUse = KEY_ALIASES[matchingStandardKey || ''] || matchingStandardKey || key;
                     if (!isSingleChar && !isStandardKey) {
                         const previousState = ActionResult.fromState(stateManager.getCurrentState());
                         const action = explorer.action();
@@ -405,7 +405,7 @@ export function createCodeceptJSTools({ explorer, stateManager, judge }, task) {
                         commandsExecuted: lines.length,
                         attempts: action.executedSteps,
                         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").',
+                        suggestion: 'Check the filled values with verify() before submitting, then submit with click().',
                     }, action);
                 }
                 catch (error) {
@@ -587,7 +587,7 @@ export function createAgentTools({ explorer, stateManager, ai, judge, researcher
             inputSchema: z.object({
                 reason: z.string().describe('Why do you need fresh context? Required to prevent overuse.'),
             }),
-            execute: async ({ reason }) => {
+            execute: async () => {
                 try {
                     const currentState = stateManager.getCurrentState();
                     if (!currentState) {
@@ -656,6 +656,7 @@ export function createAgentTools({ explorer, stateManager, ai, judge, researcher
                         });
                     }
                     return failedToolResult('verify', `Verification failed: ${assertion}`, {
+                        attempts: result.results.map(({ code, passed, error }) => ({ code, passed, error })),
                         suggestion: 'The assertion could not be verified. Check if the condition is actually present on the page or try a different assertion.',
                     });
                 }
@@ -689,7 +690,7 @@ export function createAgentTools({ explorer, stateManager, ai, judge, researcher
             inputSchema: z.object({
                 reason: z.string().describe('Why do you need research? What information is missing from existing context?'),
             }),
-            execute: async ({ reason }) => {
+            execute: async () => {
                 try {
                     const currentState = stateManager.getCurrentState();
                     if (!currentState) {
@@ -795,7 +796,7 @@ export function createAgentTools({ explorer, stateManager, ai, judge, researcher
                 element: z.string().describe('Visual description of element to click (e.g., "blue Submit button in the modal footer", "Settings gear icon in top right")'),
                 context: z.string().describe('What you already tried and why it failed - helps with accurate identification'),
             }),
-            execute: async ({ element, context }) => {
+            execute: async ({ element }) => {
                 if (Stats.visionDisabled) {
                     return failedToolResult('visualClick', 'Vision tools are disabled for this session. Use xpathCheck() to find the element, then click() with the discovered locator.');
                 }
@@ -929,7 +930,7 @@ export function createAgentTools({ explorer, stateManager, ai, judge, researcher
                 xpath: z.string().describe('XPath expression — use broad patterns to avoid missing the element'),
                 reason: z.string().describe('What element you are looking for and why'),
             }),
-            execute: async ({ xpath, reason }) => {
+            execute: async ({ xpath }) => {
                 const currentState = stateManager.getCurrentState();
                 if (!currentState) {
                     return failedToolResult('xpathCheck', 'No current page state available.');
@@ -1048,6 +1049,7 @@ const ARIA_OUTPUT_CAP = 4000;
 const HTML_OUTPUT_CAP = 6000;
 const ANALYSIS_OUTPUT_CAP = 2000;
 const JUDGE_RECENT_ACTIONS_LIMIT = 8;
+const KEY_ALIASES = { Esc: 'Escape', Del: 'Delete' };
 function cap(text, max) {
     if (!text)
         return '';

package/dist/src/application-spec.d.ts

@@ -2,10 +2,12 @@ import { ActionResult } from './action-result.js';
 export declare class ApplicationSpec {
     pages: ApplicationSpecPage[];
     readonly sourcePath: string;
+    totalMarkdownFiles: number;
     constructor(sourcePath: string);
     renderFor(state: ActionResult): string;
     matchedUrls(state: ActionResult): string[];
     get pageCount(): number;
+    get markdownFileCount(): number;
     load(): void;
     resolveSourcePath(sourcePath: string): string;
     relevantPages(state: ActionResult): ApplicationSpecPage[];

package/dist/src/application-spec.js

@@ -8,6 +8,7 @@ import { loadMarkdownFiles } from "./utils/markdown-files.js";
 export class ApplicationSpec {
     pages = [];
     sourcePath;
+    totalMarkdownFiles = 0;
     constructor(sourcePath) {
         this.sourcePath = this.resolveSourcePath(sourcePath);
         this.load();
@@ -31,24 +32,23 @@ export class ApplicationSpec {
     get pageCount() {
         return this.pages.length;
     }
+    get markdownFileCount() {
+        return this.totalMarkdownFiles;
+    }
     load() {
         if (!existsSync(this.sourcePath)) {
             throw new Error(`Application spec not found: ${this.sourcePath}`);
         }
         const isDirectory = statSync(this.sourcePath).isDirectory();
-        if (!isDirectory && path.basename(this.sourcePath).toLowerCase() !== 'index.md') {
-            throw new Error(`Application spec file must be index.md: ${this.sourcePath}`);
-        }
         const bundlePath = isDirectory ? this.sourcePath : path.dirname(this.sourcePath);
+        const allFiles = loadMarkdownFiles(bundlePath, { recursive: true });
         const indexPath = path.join(bundlePath, 'index.md');
-        if (!existsSync(indexPath)) {
-            throw new Error(`Application spec index not found: ${indexPath}`);
-        }
-        const pagesPath = path.join(bundlePath, 'pages');
-        if (!existsSync(pagesPath)) {
-            throw new Error(`Application spec pages directory not found: ${pagesPath}`);
-        }
-        for (const file of loadMarkdownFiles(pagesPath, { recursive: true })) {
+        this.totalMarkdownFiles = allFiles.filter((file) => path.resolve(file.filePath) !== path.resolve(indexPath)).length;
+        for (const file of allFiles) {
+            if (path.resolve(file.filePath) === path.resolve(indexPath))
+                continue;
+            if (!file.data.url && file.data.format === undefined && file.data.version === undefined)
+                continue;
             const parsed = APPLICATION_SPEC_PAGE_SCHEMA.safeParse(file.data);
             if (!parsed.success && parsed.error.issues.some((issue) => issue.path[0] === 'format')) {
                 throw new Error(`Invalid application spec format in ${file.filePath}`);
@@ -61,8 +61,13 @@ export class ApplicationSpec {
             }
             this.pages.push({ url: parsed.data.url, content: file.content.trim() });
         }
+        if (this.totalMarkdownFiles === 0) {
+            tag('warning').log(`No markdown files found in spec: ${bundlePath}`);
+            return;
+        }
         if (this.pages.length === 0) {
-            throw new Error(`Application spec contains no documented pages: ${pagesPath}`);
+            tag('debug').log(`${this.totalMarkdownFiles} spec files found in ${bundlePath}`);
+            return;
         }
     }
     resolveSourcePath(sourcePath) {

package/dist/src/commands/context-experience-command.js

@@ -7,7 +7,6 @@ export class ContextExperienceCommand extends BaseCommand {
     name = 'context:experience';
     description = 'Print all matching experience for current page';
     async execute(_args) {
-        const explorer = this.explorBot.getExplorer();
         const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page');

package/dist/src/commands/context-knowledge-command.js

@@ -7,7 +7,6 @@ export class ContextKnowledgeCommand extends BaseCommand {
     name = 'context:knowledge';
     description = 'Print all matching knowledge for current page';
     async execute(_args) {
-        const explorer = this.explorBot.getExplorer();
         const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page');

package/dist/src/commands/explore-command.d.ts

@@ -34,18 +34,19 @@ export declare class ExploreCommand extends BaseCommand {
     discoverNewSubPages(mainPlan: Plan, mainUrl: string | undefined, styles: string[] | undefined, knownUrls: Set<string>): Promise<void>;
     explorePage(url: string, feature: string | undefined, parentPlan: Plan | undefined, styles?: string[]): Promise<boolean>;
     replanAndRun(pageUrl: string | undefined, feature: string | undefined, existingPlan: Plan, styles?: string[]): Promise<void>;
-    runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[], styles?: string[]): Promise<void>;
+    runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, styles?: string[]): Promise<void>;
     rememberCurrentPlan(): void;
     planWithRetry(feature: string | undefined, opts: {
         fresh: boolean;
         style: string;
         extend?: Plan;
-        completedPlans?: Plan[];
         noSave?: boolean;
     }, pageUrl?: string): Promise<void>;
+    printAddedTests(before: Set<Test>, style: string, pageUrl?: string): number;
     parseConfigure(raw: string | undefined): ConfigureSpec;
     printResults(): void;
     printNextSteps(savedPlanPath?: string | null): void;
+    skipBlockedTest(test: Test, error: unknown): void;
     isLimitReached(): boolean;
     isDeadlineReached(): boolean;
     runPendingTests(): Promise<void>;

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

@@ -6,7 +6,7 @@ import { Stats } from '../stats.js';
 import { TestResult } from '../test-plan.js';
 import { browserErrorMessage } from "../utils/browser-errors.js";
 import { getCliName } from "../utils/cli-name.js";
-import { ErrorPageError, getStateErrorPageError } from "../utils/error-page.js";
+import { BlockedError, ErrorPageError, getStateErrorPageError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
 import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { keepSiteUrls, readSitemap } from "../utils/sitemap.js";
@@ -14,6 +14,7 @@ import { parseSpecPairs } from "../utils/spec.js";
 import { safeFilename } from "../utils/strings.js";
 import { UrlFilter } from "../utils/url-filter.js";
 import { BaseCommand } from './base-command.js';
+import { PlanCommand } from './plan-command.js';
 const MAX_SUB_PAGE_ATTEMPTS = 30;
 const PRIORITY_ORDER = { critical: 0, important: 1, high: 2, normal: 3, low: 4 };
 export const DEADLINE_RESERVE_MS = 3 * 60_000;
@@ -135,7 +136,7 @@ export class ExploreCommand extends BaseCommand {
         tag('multiline').log(lines.join('\n'), { maxLines: 24 });
     }
     async runFreshMode(mainUrl, feature, styles) {
-        await this.runAllStyles(mainUrl, feature, undefined, undefined, styles);
+        await this.runAllStyles(mainUrl, feature, undefined, styles);
         this.rememberCurrentPlan();
         const mainPlan = this.explorBot.getCurrentPlan();
         if (!mainPlan)
@@ -319,7 +320,7 @@ export class ExploreCommand extends BaseCommand {
             tag('warning').log(`Skipping page: ${errorPage.message}`);
             return false;
         }
-        await this.runAllStyles(url, feature, parentPlan, this.completedPlans, styles);
+        await this.runAllStyles(url, feature, parentPlan, styles);
         const plan = this.explorBot.getCurrentPlan();
         if (plan?.tests.length && !this.completedPlans.includes(plan)) {
             this.completedPlans.push(plan);
@@ -332,14 +333,14 @@ export class ExploreCommand extends BaseCommand {
             if (this.isLimitReached())
                 break;
             this.explorBot.setCurrentPlan(existingPlan);
-            const opts = { fresh: false, style, completedPlans: this.completedPlans };
+            const opts = { fresh: false, style };
             if (this.dryRun)
                 opts.noSave = true;
             await this.planWithRetry(feature, opts, pageUrl);
             await this.runPendingTests();
         }
     }
-    async runAllStyles(pageUrl, feature, parentPlan, completedPlans, styles) {
+    async runAllStyles(pageUrl, feature, parentPlan, styles) {
         const styleList = styles ?? Object.keys(getStyles());
         let fresh = true;
         for (const style of styleList) {
@@ -348,7 +349,7 @@ export class ExploreCommand extends BaseCommand {
             if (!fresh && pageUrl && !this.dryRun) {
                 await this.explorBot.visit(pageUrl);
             }
-            const opts = { fresh, style, completedPlans };
+            const opts = { fresh, style };
             if (fresh && parentPlan)
                 opts.extend = parentPlan;
             if (this.dryRun)
@@ -377,6 +378,10 @@ export class ExploreCommand extends BaseCommand {
     async planWithRetry(feature, opts, pageUrl) {
         const before = new Set(this.explorBot.getCurrentPlan()?.tests ?? []);
         await this.explorBot.plan(feature, opts);
+        if (this.explorBot.lastPlanError instanceof BlockedError) {
+            tag('warning').log(`Skipping page: ${this.explorBot.lastPlanError.message}`);
+            return;
+        }
         if (this.explorBot.lastPlanError) {
             if (this.explorBot.lastPlanError instanceof ErrorPageError) {
                 throw this.explorBot.lastPlanError;
@@ -390,14 +395,15 @@ export class ExploreCommand extends BaseCommand {
                 return;
             }
         }
-        const planAfter = this.explorBot.getCurrentPlan();
-        if (!planAfter)
-            return;
-        const added = planAfter.tests.filter((t) => !before.has(t));
+        this.printAddedTests(before, opts.style, pageUrl);
+    }
+    printAddedTests(before, style, pageUrl) {
+        const added = this.explorBot.getCurrentPlan()?.tests.filter((t) => !before.has(t)) ?? [];
         if (added.length === 0)
-            return;
+            return 0;
         const urlNote = pageUrl ? ` for ${pageUrl}` : '';
-        this.printPreview(`Planner added ${added.length} new test(s) [style=${opts.style}]${urlNote}:`, added);
+        this.printPreview(`Planner added ${added.length} new test(s) [style=${style}]${urlNote}:`, added);
+        return added.length;
     }
     parseConfigure(raw) {
         const cfg = { enabled: false, newRatio: 1.0 };
@@ -542,16 +548,7 @@ export class ExploreCommand extends BaseCommand {
         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` },
-                ],
-            });
+            sections.push(PlanCommand.planSection(savedPlanPath));
         }
         const savedFiles = this.explorBot.agentHistorian().getSavedFiles();
         const screencasts = savedFiles.filter((f) => f.endsWith('.webm'));
@@ -585,6 +582,14 @@ export class ExploreCommand extends BaseCommand {
         });
         printNextSteps(sections);
     }
+    skipBlockedTest(test, error) {
+        if (!(error instanceof BlockedError))
+            throw error;
+        tag('warning').log(`Skipping test: ${error.message}`);
+        test.start();
+        test.addNote(error.message, TestResult.SKIPPED);
+        test.finish(TestResult.SKIPPED);
+    }
     isLimitReached() {
         if (this.maxTests != null && this.testsRun >= this.maxTests)
             return true;
@@ -623,7 +628,14 @@ export class ExploreCommand extends BaseCommand {
             test.finish(TestResult.SKIPPED);
         }
         else {
-            await this.explorBot.agentTester().test(test, { deadline: this.hardDeadlineAt });
+            const run = () => this.explorBot.agentTester().test(test, { deadline: this.hardDeadlineAt });
+            await run()
+                .catch(async (err) => {
+                if (!(await this.explorBot.agentCaptain().resolveBlocker(err, () => this.explorBot.agentNavigator().isOn(test.startUrl))))
+                    throw err;
+                return run();
+            })
+                .catch((err) => this.skipBlockedTest(test, err));
         }
         this.testsRun++;
     }

package/dist/src/commands/help-json-command.js

@@ -27,7 +27,9 @@ export class HelpJsonCommand {
                 required: argument.required,
                 variadic: argument.variadic,
             })),
-            options: helper.visibleOptions(cmd).map((option) => ({
+            options: cmd.options
+                .filter((option) => !option.hidden)
+                .map((option) => ({
                 flags: option.flags,
                 description: option.description,
                 default: option.defaultValue,

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

@@ -1,6 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, extname, join, resolve } from 'node:path';
-import chalk from 'chalk';
 import figureSet from 'figures';
 import { ConfigParser, PROVIDERS, missingModelRoles } from "../config.js";
 import { findGlobalConfig, globalConfigPath, globalDir, globalEnvPath } from "../global-config.js";
@@ -299,10 +298,11 @@ function printInitNextSteps(options) {
         label: 'Docs',
         commands: [{ command: 'https://testomat.ai/docs/explorbot' }],
     });
+    sections.push({
+        label: 'Add knowledge (logins, credentials) — created on first use in ./knowledge',
+        commands: [{ command: `${cli} learn '*' 'to authorize use these credentials: admin@example.com / secret123'` }],
+    });
     printNextSteps(sections);
-    log('');
-    log('Add knowledge (logins, credentials) — created on first use in ./knowledge:');
-    tag('substep').log(chalk.yellow(`${cli} learn '*' 'to authorize use these credentials: admin@example.com / secret123'`));
     tag('substep').log('You can use ${env.LOGIN} and ${env.PASSWORD} to reference environment variables.');
 }
 function writeEnvKey(key, value, envPath = globalEnvPath()) {

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

@@ -10,7 +10,6 @@ export class LearnCommand extends BaseCommand {
         const note = args.trim();
         if (!note) {
             const AddKnowledge = (await import('../components/AddKnowledge.js')).default;
-            const explorer = this.explorBot.getExplorer();
             const state = this.explorBot.stateManager().getCurrentState();
             const initialUrl = state?.url || '';
             const { unmount } = render(React.createElement(AddKnowledge, {
@@ -24,7 +23,6 @@ export class LearnCommand extends BaseCommand {
             });
             return;
         }
-        const explorer = this.explorBot.getExplorer();
         const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page to attach knowledge');

package/dist/src/commands/plan-command.d.ts

@@ -1,3 +1,4 @@
+import { type NextStepSection } from '../utils/next-steps.js';
 import { BaseCommand, type Suggestion } from './base-command.js';
 export declare class PlanCommand extends BaseCommand {
     name: string;
@@ -8,7 +9,9 @@ export declare class PlanCommand extends BaseCommand {
         description: string;
     }[];
     execute(args: string): Promise<void>;
+    static planSection(planPath: string, cliSuffix?: string): NextStepSection;
     printNextSteps(): void;
+    cliSuffix(): string;
     printPlanSummary(): void;
     updateSuggestions(): void;
 }

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

@@ -1,3 +1,4 @@
+import { existsSync } from 'node:fs';
 import path from 'node:path';
 import chalk from 'chalk';
 import figureSet from 'figures';
@@ -16,8 +17,12 @@ export class PlanCommand extends BaseCommand {
     options = [
         { flags: '--fresh', description: 'Regenerate plan from scratch' },
         { flags: '--clear', description: 'Clear plan before regenerating' },
+        { flags: '--append', description: 'Add tests to existing plan file' },
         { flags: '--style <name>', description: 'Planning style (normal, curious, psycho, performer)' },
         { flags: '--focus <feature>', description: 'Focus area for test planning' },
+        { flags: '--tests <count>', description: 'Exact number of tests to generate' },
+        { flags: '--min-tests <count>', description: 'Minimum number of tests to generate' },
+        { flags: '--max-tests <count>', description: 'Maximum number of tests to generate' },
     ];
     async execute(args) {
         const { opts, args: remaining } = this.parseArgs(args);
@@ -26,10 +31,18 @@ export class PlanCommand extends BaseCommand {
             this.explorBot.clearPlan();
             tag('success').log('Plan cleared');
         }
+        if (opts.append) {
+            const existingPlanPath = path.join(this.explorBot.getPlansDir(), this.explorBot.generatePlanFilename());
+            if (existsSync(existingPlanPath))
+                this.explorBot.loadPlan(existingPlanPath);
+        }
         if (focus) {
             tag('info').log(`Planning focus: ${focus}`);
         }
-        await this.explorBot.plan(focus, { fresh: !!(opts.fresh || opts.clear), style: opts.style });
+        const testsCount = opts.tests ? Number.parseInt(opts.tests, 10) : undefined;
+        const minTests = testsCount ?? (opts.minTests ? Number.parseInt(opts.minTests, 10) : undefined);
+        const maxTests = testsCount ?? (opts.maxTests ? Number.parseInt(opts.maxTests, 10) : undefined);
+        await this.explorBot.plan(focus, { fresh: !!(opts.fresh || opts.clear), style: opts.style, minTests, maxTests });
         const plan = this.explorBot.getCurrentPlan();
         if (!plan?.tests.length) {
             throw new Error('No test scenarios in the current plan.');
@@ -38,28 +51,32 @@ export class PlanCommand extends BaseCommand {
         this.updateSuggestions();
         this.printNextSteps();
     }
+    static planSection(planPath, cliSuffix = '') {
+        const cli = getCliName();
+        const planName = path.basename(planPath, '.md');
+        return {
+            label: 'Plan',
+            path: planPath,
+            commands: [
+                { label: 'Run all tests', command: `${cli} test ${planName}${cliSuffix}` },
+                { label: 'Run one test', command: `${cli} test ${planName} 1${cliSuffix}` },
+                { label: 'Run a range', command: `${cli} test ${planName} 1-3${cliSuffix}` },
+            ],
+        };
+    }
     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 cliSuffix = this.cliSuffix();
+        const section = PlanCommand.planSection(savedPath, cliSuffix);
+        section.commands?.push({ label: 'Reload', command: `/plan:load ${path.basename(savedPath, '.md')}` });
+        const sections = [section];
         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)}` }));
+            const commands = files.map((f) => ({ label: '', command: `${cli} rerun ${relativeToCwd(f)}${cliSuffix}` }));
             sections.push({
                 label: `Automated tests (${files.length})`,
                 commands,
@@ -67,6 +84,15 @@ export class PlanCommand extends BaseCommand {
         }
         printNextSteps(sections);
     }
+    cliSuffix() {
+        const options = this.explorBot.getOptions();
+        let suffix = '';
+        if (options.path)
+            suffix += ` --path ${options.path}`;
+        if (options.session)
+            suffix += ' --session';
+        return suffix;
+    }
     printPlanSummary() {
         const suite = this.explorBot.getSuite();
         const plan = this.explorBot.getCurrentPlan();
@@ -78,10 +104,10 @@ export class PlanCommand extends BaseCommand {
             }
         }
         if (plan?.tests.length) {
-            console.log(`\n${chalk.bold.cyan(`New test scenarios (${plan.tests.length})`)}`);
+            console.log(`\n${chalk.bold.cyan(`New test scenarios (${plan.tests.length})`)}\n`);
             for (let i = 0; i < plan.tests.length; i++) {
                 const t = plan.tests[i];
-                console.log(`  ${chalk.dim(`${i + 1}.`)} ${chalk.green(figureSet.pointer)} ${t.scenario} ${chalk.dim(`[${t.priority}]`)}`);
+                console.log(`  ${chalk.cyan(`${i + 1}.`)} ${t.scenario}`);
             }
         }
     }

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

@@ -1,5 +1,6 @@
-import { getCliName } from "../utils/cli-name.js";
-import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
+import path from 'node:path';
+import { printNextSteps } from "../utils/next-steps.js";
+import { PlanCommand } from './plan-command.js';
 import { BaseCommand } from './base-command.js';
 export class PlanSaveCommand extends BaseCommand {
     name = 'plan:save';
@@ -14,20 +15,8 @@ export class PlanSaveCommand extends BaseCommand {
         const savedPath = this.explorBot.savePlan(filename);
         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}` },
-                ],
-            },
-        ];
-        printNextSteps(sections);
+        const section = PlanCommand.planSection(savedPath);
+        section.commands?.push({ label: 'Reload', command: `/plan:load ${path.basename(savedPath, '.md')}` });
+        printNextSteps([section]);
     }
 }

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

@@ -44,7 +44,7 @@ export class PlansCommand extends BaseCommand {
         }
         tag('info').log('');
         tag('info').log('Run test from this plan as:');
-        tag('info').log(`${getCliName()} test 1 --from-plan ${file.name}`);
+        tag('info').log(`${getCliName()} test ${file.name} 1`);
     }
     resolvePlanFile(target, files) {
         const index = Number.parseInt(target, 10);

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

@@ -1,5 +1,6 @@
 import { Stats } from '../stats.js';
 import { Plan, Test } from '../test-plan.js';
+import { BlockedError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
 import { BaseCommand } from './base-command.js';
 export class TestCommand extends BaseCommand {
@@ -15,6 +16,11 @@ export class TestCommand extends BaseCommand {
         if (opts.fromPlan) {
             this.explorBot.loadPlan(String(opts.fromPlan));
         }
+        if (!opts.fromPlan && remaining[0] && Plan.resolveFile(remaining[0], this.explorBot.getPlansDir())) {
+            this.explorBot.loadPlan(remaining.shift());
+            if (remaining.length === 0)
+                remaining.push('*');
+        }
         const plan = this.explorBot.getCurrentPlan();
         const selector = remaining.join(' ');
         Stats.mode = 'test';
@@ -70,12 +76,16 @@ export class TestCommand extends BaseCommand {
         const tester = this.explorBot.agentTester();
         for (const [index, test] of toExecute.entries()) {
             tag('info').log(`Starting test ${index + 1}/${toExecute.length}: ${test.scenario}`);
-            await tester.test(test);
+            await tester.test(test).catch((err) => {
+                if (!(err instanceof BlockedError))
+                    throw err;
+                tag('warning').log(`Skipping test: ${err.message}`);
+            });
         }
         tag('success').log('Test execution finished');
     }
     completeArguments() {
-        return Plan.listFiles(this.explorBot.getPlansDir()).map((file) => ({ value: `--from-plan ${file.name}`, display: file.label }));
+        return Plan.listFiles(this.explorBot.getPlansDir()).map((file) => ({ value: file.name, display: file.label }));
     }
 }
 function parseTestIndices(input, total) {

package/dist/src/components/App.d.ts

@@ -3,7 +3,6 @@ import type { ExplorBot } from '../explorbot.js';
 interface AppProps {
     explorBot: ExplorBot;
     initialShowInput?: boolean;
-    exitOnEmptyInput?: boolean;
 }
-export declare function App({ explorBot, initialShowInput, exitOnEmptyInput }: AppProps): React.JSX.Element;
+export declare function App({ explorBot, initialShowInput }: AppProps): React.JSX.Element;
 export {};

package/dist/src/components/App.js

@@ -13,14 +13,13 @@ import StateTransitionPane from './StateTransitionPane.js';
 import TaskPane, { WINDOW_SIZE } from './TaskPane.js';
 import WelcomeChecklist from './WelcomeChecklist.js';
 import WelcomeCommands from './WelcomeCommands.js';
-export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = false }) {
+export function App({ explorBot, initialShowInput = false }) {
     const sessionStartedAtRef = useRef(Date.now());
     const InputComponent = InputReadline;
     const [showSessionTimer, setShowSessionTimer] = useState(false);
     const [showInput, setShowInput] = useState(initialShowInput);
     const [interruptPrompt, setInterruptPrompt] = useState(null);
     const [currentState, setCurrentState] = useState(null);
-    const [lastTransition, setLastTransition] = useState(null);
     const [tasks, setTasks] = useState([]);
     const tasksRef = useRef([]);
     const [showPlanEditor, setShowPlanEditor] = useState(false);
@@ -50,7 +49,6 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
         const manager = explorBot.stateManager();
         unsubscribe = manager.onStateChange((transition) => {
             if (mounted) {
-                setLastTransition(transition);
                 setCurrentState(transition.toState);
             }
         });