explorbot 0.1.16 → 0.1.17

package/bin/explorbot-cli.ts

@@ -122,7 +122,15 @@ addCommonOptions(program.command('start [path]').description('Start web explorat
   await startTUI(explorBot);
 });
 
-addCommonOptions(program.command('explore <path>').description('Explore a page autonomously and run invented scenarios').option('--max-tests <count>', 'Maximum number of tests to run').option('--focus <feature>', 'Focus area for exploration')).action(async (explorePath, options) => {
+addCommonOptions(
+  program
+    .command('explore <path>')
+    .description('Explore a page autonomously and run invented scenarios')
+    .option('--max-tests <count>', 'Maximum number of tests to run')
+    .option('--focus <feature>', 'Focus area for exploration')
+    .option('--configure <spec>', 'Reuse spec: keys new|from|style|subpages|pick_by|priority, e.g. "new:25%;pick_by=random;priority=critical,high"')
+    .option('--dry-run', 'Mark picked tests as skipped without executing or generating new ones')
+).action(async (explorePath, options) => {
   try {
     const explorBot = new ExplorBot(buildExplorBotOptions(explorePath, options));
     await explorBot.start();
@@ -130,8 +138,11 @@ addCommonOptions(program.command('explore <path>').description('Explore a page a
     const { ExploreCommand } = await import('../src/commands/explore-command.js');
     const cmd = new ExploreCommand(explorBot);
     if (options.maxTests) cmd.maxTests = Number.parseInt(options.maxTests, 10);
+    if (options.dryRun) cmd.dryRun = true;
     const execArgs: string[] = [];
     if (options.focus) execArgs.push('--focus', `"${options.focus}"`);
+    if (options.configure) execArgs.push('--configure', `"${options.configure}"`);
+    if (options.dryRun) execArgs.push('--dry-run');
     await cmd.execute(execArgs.join(' '));
     await explorBot.stop();
     await showStatsAndExit(0);

package/dist/bin/explorbot-cli.js

@@ -93,7 +93,13 @@ addCommonOptions(program.command('start [path]').description('Start web explorat
     await explorBot.start();
     await startTUI(explorBot);
 });
-addCommonOptions(program.command('explore <path>').description('Explore a page autonomously and run invented scenarios').option('--max-tests <count>', 'Maximum number of tests to run').option('--focus <feature>', 'Focus area for exploration')).action(async (explorePath, options) => {
+addCommonOptions(program
+    .command('explore <path>')
+    .description('Explore a page autonomously and run invented scenarios')
+    .option('--max-tests <count>', 'Maximum number of tests to run')
+    .option('--focus <feature>', 'Focus area for exploration')
+    .option('--configure <spec>', 'Reuse spec: keys new|from|style|subpages|pick_by|priority, e.g. "new:25%;pick_by=random;priority=critical,high"')
+    .option('--dry-run', 'Mark picked tests as skipped without executing or generating new ones')).action(async (explorePath, options) => {
     try {
         const explorBot = new ExplorBot(buildExplorBotOptions(explorePath, options));
         await explorBot.start();
@@ -102,9 +108,15 @@ addCommonOptions(program.command('explore <path>').description('Explore a page a
         const cmd = new ExploreCommand(explorBot);
         if (options.maxTests)
             cmd.maxTests = Number.parseInt(options.maxTests, 10);
+        if (options.dryRun)
+            cmd.dryRun = true;
         const execArgs = [];
         if (options.focus)
             execArgs.push('--focus', `"${options.focus}"`);
+        if (options.configure)
+            execArgs.push('--configure', `"${options.configure}"`);
+        if (options.dryRun)
+            execArgs.push('--dry-run');
         await cmd.execute(execArgs.join(' '));
         await explorBot.stop();
         await showStatsAndExit(0);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/dist/src/ai/pilot.js

@@ -277,14 +277,9 @@ export class Pilot {
       - "Edit X" → updated value must be persisted (visible in list/detail). Opening edit is NOT enough; redirect after save with the new value visible IS enough.
       - Negative tests ("without a name", "invalid", "duplicate", "unauthorized") → success means the system PREVENTED the action with validation/error.
 
-      PROVENANCE for create/edit scenarios: the task prompt instructs the tester to inject the
-      session marker "${task.sessionName ?? ''}" into newly created or edited free-text values.
-      When that marker COULD be injected, the entity used as proof MUST contain it. A record
-      matching the goal by text alone but missing the marker is a stale leftover from a prior
-      run — it is NOT evidence the current scenario produced anything. Vote \`fail\`, not \`pass\`.
-      This does not apply when the field is restricted (numeric only, enum, etc.) or when the
-      session_log shows no fillField/type/select actions were attempted at all (in that case
-      the scenario clearly didn't run — also vote \`fail\`).
+      PROVENANCE: the entity you cite as proof must appear by name in <notes> or
+      <session_log> tool inputs for THIS run. Name absent from tester activity = stale
+      coincidence, vote \`fail\`. Same if no fillField/type/select/click on a target ran.
 
       Expected results are MILESTONES, not the goal. Never fail because a milestone (toast, icon, styling)
       didn't match if the scenario goal IS accomplished.

package/dist/src/ai/tester.js

@@ -648,6 +648,7 @@ export class Tester extends TaskAgent {
     - Use pressKey() for pressing special keys (Enter, Escape, Tab, Arrow keys) or key combinations with modifiers (Ctrl+A, Shift+Delete, etc.)
     - Use container CSS locators from <page_ui_map> to interact with elements inside sections
     - Systematically use record({ notes: ["..."] }) to write your findings, planned actions, observations, etc.
+    - When creating/editing/deleting a named entity, include its identifier verbatim in the note — Pilot uses it to confirm provenance.
     - Call record({ notes: ["..."], status: "success" }) when you see success/info message on a page or when expected outcome is achieved
     - Call record({ notes: ["..."], status: "fail" }) when an expected outcome cannot be achieved or has failed or you see error/alert/warning message on a page
     - NEVER call record(status: "success") if your last verify() or see() call FAILED. A failed check means the outcome is NOT confirmed — use record(status: "fail") instead, or retry with a different approach.

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

@@ -3,6 +3,7 @@ import { getStyles } from '../ai/planner/styles.js';
 import { outputPath } from '../config.js';
 import { normalizeUrl } from '../state-manager.js';
 import { Stats } from '../stats.js';
+import { TestResult } from '../test-plan.js';
 import { getCliName } from "../utils/cli-name.js";
 import { ErrorPageError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
@@ -11,12 +12,15 @@ import { printNextSteps, relativeToCwd } from "../utils/next-steps.js";
 import { safeFilename } from "../utils/strings.js";
 import { BaseCommand } from './base-command.js';
 const MAX_SUB_PAGE_ATTEMPTS = 30;
+const PRIORITY_ORDER = { critical: 0, important: 1, high: 2, normal: 3, low: 4 };
 export class ExploreCommand extends BaseCommand {
     name = 'explore';
     description = 'Start web exploration';
     options = [
         { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
         { flags: '--focus <feature>', description: 'Focus area for exploration' },
+        { flags: '--configure <spec>', description: 'Reuse spec: keys new|from|style|subpages|pick_by|priority, e.g. "new:25%;pick_by=random;priority=critical,high"' },
+        { flags: '--dry-run', description: 'Mark picked tests as skipped without executing or generating new ones' },
     ];
     suggestions = [
         { command: 'navigate <page>', hint: 'go to another page' },
@@ -24,93 +28,370 @@ export class ExploreCommand extends BaseCommand {
         { command: 'plan <feature>', hint: 'plan testing' },
     ];
     maxTests;
+    dryRun = false;
     testsRun = 0;
     completedPlans = [];
     failedSubPages = new Set();
+    oldTestRefs = new Set();
+    priorityFilter;
     async execute(args) {
         const { opts, args: remaining } = this.parseArgs(args);
         if (opts.maxTests) {
             this.maxTests = Number.parseInt(opts.maxTests, 10);
         }
         const feature = opts.focus || remaining.join(' ') || undefined;
+        const cfg = this.parseConfigure(opts.configure);
+        if (cfg.priorities)
+            this.priorityFilter = new Set(cfg.priorities);
+        if (opts.dryRun)
+            this.dryRun = true;
+        if (this.dryRun)
+            tag('info').log('Dry-run mode: planner runs to discover new tests; test execution is skipped');
         Stats.mode ??= 'explore';
         Stats.focus ??= feature;
         const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
-        await this.runAllStyles(mainUrl, feature);
+        if (cfg.enabled) {
+            await this.runReuseMode(mainUrl, feature, cfg);
+        }
+        else {
+            await this.runFreshMode(mainUrl, feature, cfg.styles);
+        }
+        const mainPlan = this.completedPlans[0];
+        if (mainPlan)
+            this.explorBot.setCurrentPlan(mainPlan);
+        if (this.dryRun) {
+            this.printResults();
+            return;
+        }
+        if (mainUrl)
+            await this.explorBot.visit(mainUrl);
+        const savedPath = this.explorBot.savePlans(this.completedPlans);
+        this.printResults();
+        await this.explorBot.printSessionAnalysis();
+        this.printNextSteps(savedPath);
+    }
+    originLabel(test) {
+        return this.oldTestRefs.has(test) ? 'OLD' : 'NEW';
+    }
+    printPreview(label, tests) {
+        if (tests.length === 0)
+            return;
+        const lines = [label];
+        for (let i = 0; i < tests.length; i++) {
+            const t = tests[i];
+            lines.push(`  ${String(i + 1).padStart(2)}. [${this.originLabel(t)}] [${t.priority.padEnd(9)}] ${t.scenario}`);
+        }
+        tag('multiline').log(lines.join('\n'));
+    }
+    async runFreshMode(mainUrl, feature, styles) {
+        await this.runAllStyles(mainUrl, feature, undefined, undefined, styles);
         const mainPlan = this.explorBot.getCurrentPlan();
         if (!mainPlan)
             return;
         this.completedPlans.push(mainPlan);
-        if (!feature && !this.isLimitReached()) {
-            const planner = this.explorBot.agentPlanner();
-            let attempts = 0;
-            while (attempts < MAX_SUB_PAGE_ATTEMPTS) {
-                attempts++;
+        if (feature || this.isLimitReached())
+            return;
+        await this.discoverNewSubPages(mainPlan, mainUrl, styles, new Set());
+    }
+    async runReuseMode(mainUrl, feature, cfg) {
+        const filename = cfg.fromPath || this.explorBot.generatePlanFilename(feature);
+        let loadedPlans = [];
+        try {
+            loadedPlans = this.explorBot.loadPlans(filename);
+        }
+        catch (err) {
+            tag('warning').log(`Reuse plan not found (${err instanceof Error ? err.message : err}); falling back to fresh planning`);
+            await this.runFreshMode(mainUrl, feature, cfg.styles);
+            return;
+        }
+        if (loadedPlans.length === 0) {
+            tag('warning').log('Reuse plan empty; falling back to fresh planning');
+            await this.runFreshMode(mainUrl, feature, cfg.styles);
+            return;
+        }
+        const mainPlan = loadedPlans[0];
+        const subPlans = loadedPlans.slice(1);
+        const totalCap = this.maxTests ?? Number.POSITIVE_INFINITY;
+        let newQuota = Number.POSITIVE_INFINITY;
+        let oldQuota = Number.POSITIVE_INFINITY;
+        if (Number.isFinite(totalCap)) {
+            newQuota = Math.round(totalCap * cfg.newRatio);
+            oldQuota = Math.max(0, totalCap - newQuota);
+        }
+        for (const p of loadedPlans) {
+            for (const t of p.tests)
+                this.oldTestRefs.add(t);
+        }
+        const allOldTests = loadedPlans.flatMap((p) => p.tests.filter((t) => t.status === 'pending'));
+        let matchingOldTests = allOldTests;
+        if (cfg.styles) {
+            matchingOldTests = matchingOldTests.filter((t) => !t.style || cfg.styles.includes(t.style));
+        }
+        if (this.priorityFilter) {
+            matchingOldTests = matchingOldTests.filter((t) => this.priorityFilter.has(t.priority));
+        }
+        const pickBy = cfg.pickBy ?? 'priority';
+        const orderedOldTests = matchingOldTests.slice();
+        if (pickBy === 'priority') {
+            orderedOldTests.sort((a, b) => (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99));
+        }
+        else if (pickBy === 'random') {
+            for (let i = orderedOldTests.length - 1; i > 0; i--) {
+                const j = Math.floor(Math.random() * (i + 1));
+                [orderedOldTests[i], orderedOldTests[j]] = [orderedOldTests[j], orderedOldTests[i]];
+            }
+        }
+        let pickCount = orderedOldTests.length;
+        if (Number.isFinite(oldQuota))
+            pickCount = Math.min(oldQuota, orderedOldTests.length);
+        const picked = orderedOldTests.slice(0, pickCount);
+        const pickedSet = new Set(picked);
+        for (const t of allOldTests) {
+            if (!pickedSet.has(t))
+                t.enabled = false;
+        }
+        let newQuotaLabel = 'unlimited';
+        if (Number.isFinite(newQuota))
+            newQuotaLabel = String(newQuota);
+        let priorityNote = '';
+        if (this.priorityFilter)
+            priorityNote = `, priority=[${[...this.priorityFilter].join(',')}]`;
+        tag('info').log(`Reuse: loaded ${allOldTests.length} old test(s), running ${picked.length} (pick_by=${pickBy}${priorityNote}), reserving ${newQuotaLabel} for new`);
+        const planner = this.explorBot.agentPlanner();
+        for (const p of loadedPlans)
+            planner.registerPlanInSession(p);
+        this.completedPlans.push(...loadedPlans);
+        this.printPreview(`Picked old tests (${picked.length}):`, picked);
+        let currentPlanRef;
+        for (const test of picked) {
+            if (this.isLimitReached())
+                break;
+            const owningPlan = test.plan;
+            if (owningPlan && owningPlan !== currentPlanRef) {
+                this.explorBot.setCurrentPlan(owningPlan);
+                if (owningPlan.url && !this.dryRun)
+                    await this.explorBot.visit(owningPlan.url);
+                currentPlanRef = owningPlan;
+            }
+            await this.runOneTest(test);
+        }
+        if (this.isLimitReached() || newQuota <= 0)
+            return;
+        const subpagesMode = cfg.subpages || 'both';
+        if (mainUrl && !this.dryRun)
+            await this.explorBot.visit(mainUrl);
+        await this.replanAndRun(mainUrl, feature, mainPlan, cfg.styles);
+        if (this.isLimitReached())
+            return;
+        if (subpagesMode === 'same' || subpagesMode === 'both') {
+            for (const subPlan of subPlans) {
                 if (this.isLimitReached())
                     break;
-                const candidates = planner.collectSubPageCandidates(mainPlan, mainUrl || '/').filter((c) => !this.failedSubPages.has(normalizeUrl(c.url)));
-                if (candidates.length === 0)
-                    break;
-                const pick = await planner.pickNextSubPage(candidates);
-                if (!pick)
-                    break;
-                tag('info').log(`Exploring sub-page: ${pick.url} (${pick.reason})`);
+                if (!subPlan.url)
+                    continue;
                 try {
-                    await this.explorBot.visit(pick.url);
-                    await this.runAllStyles(pick.url, undefined, mainPlan, this.completedPlans);
-                    const subPlan = this.explorBot.getCurrentPlan();
-                    if (subPlan) {
-                        this.completedPlans.push(subPlan);
-                    }
+                    if (!this.dryRun)
+                        await this.explorBot.visit(subPlan.url);
+                    await this.replanAndRun(subPlan.url, undefined, subPlan, cfg.styles);
                 }
                 catch (err) {
-                    this.failedSubPages.add(normalizeUrl(pick.url));
-                    tag('warning').log(`Sub-page exploration failed: ${err instanceof Error ? err.message : err}`);
+                    this.failedSubPages.add(normalizeUrl(subPlan.url));
+                    tag('warning').log(`Sub-page re-planning failed: ${err instanceof Error ? err.message : err}`);
                 }
             }
         }
-        this.explorBot.setCurrentPlan(mainPlan);
-        if (mainUrl)
-            await this.explorBot.visit(mainUrl);
-        const savedPath = this.explorBot.savePlans(this.completedPlans);
-        this.printResults();
-        await this.explorBot.printSessionAnalysis();
-        this.printNextSteps(savedPath);
+        if (this.isLimitReached())
+            return;
+        if (subpagesMode === 'new' || subpagesMode === 'both') {
+            const knownUrls = new Set();
+            for (const p of loadedPlans) {
+                if (p.url)
+                    knownUrls.add(normalizeUrl(p.url));
+            }
+            await this.discoverNewSubPages(mainPlan, mainUrl, cfg.styles, knownUrls);
+        }
     }
-    async runAllStyles(pageUrl, feature, parentPlan, completedPlans) {
+    async discoverNewSubPages(mainPlan, mainUrl, styles, knownUrls) {
+        const planner = this.explorBot.agentPlanner();
+        let attempts = 0;
+        while (attempts < MAX_SUB_PAGE_ATTEMPTS) {
+            attempts++;
+            if (this.isLimitReached())
+                break;
+            const candidates = planner.collectSubPageCandidates(mainPlan, mainUrl || '/').filter((c) => {
+                const norm = normalizeUrl(c.url);
+                return !this.failedSubPages.has(norm) && !knownUrls.has(norm);
+            });
+            if (candidates.length === 0)
+                break;
+            const pick = await planner.pickNextSubPage(candidates);
+            if (!pick)
+                break;
+            tag('info').log(`Exploring sub-page: ${pick.url} (${pick.reason})`);
+            try {
+                await this.explorBot.visit(pick.url);
+                await this.runAllStyles(pick.url, undefined, mainPlan, this.completedPlans, styles);
+                const subPlan = this.explorBot.getCurrentPlan();
+                if (subPlan && !this.completedPlans.includes(subPlan)) {
+                    this.completedPlans.push(subPlan);
+                }
+                knownUrls.add(normalizeUrl(pick.url));
+            }
+            catch (err) {
+                this.failedSubPages.add(normalizeUrl(pick.url));
+                tag('warning').log(`Sub-page exploration failed: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+    }
+    async replanAndRun(pageUrl, feature, existingPlan, styles) {
+        const styleList = styles ?? Object.keys(getStyles());
+        for (const style of styleList) {
+            if (this.isLimitReached())
+                break;
+            this.explorBot.setCurrentPlan(existingPlan);
+            const opts = { fresh: false, style, completedPlans: this.completedPlans };
+            if (this.dryRun)
+                opts.noSave = true;
+            await this.planWithRetry(feature, opts, pageUrl);
+            await this.runPendingTests();
+        }
+    }
+    async runAllStyles(pageUrl, feature, parentPlan, completedPlans, styles) {
+        const styleList = styles ?? Object.keys(getStyles());
         let fresh = true;
-        for (const style of Object.keys(getStyles())) {
-            if (!fresh && pageUrl) {
+        for (const style of styleList) {
+            if (!fresh && pageUrl && !this.dryRun) {
                 await this.explorBot.visit(pageUrl);
             }
             const opts = { fresh, style, completedPlans };
             if (fresh && parentPlan)
                 opts.extend = parentPlan;
+            if (this.dryRun)
+                opts.noSave = true;
             await this.planWithRetry(feature, opts, pageUrl);
             await this.runPendingTests();
             fresh = false;
         }
     }
     async planWithRetry(feature, opts, pageUrl) {
-        await this.explorBot.plan(feature, opts);
-        if (!this.explorBot.lastPlanError)
-            return;
-        if (this.explorBot.lastPlanError instanceof ErrorPageError) {
-            throw this.explorBot.lastPlanError;
-        }
-        tag('info').log(`Retrying planning style '${opts.style}'...`);
-        if (pageUrl)
-            await this.explorBot.visit(pageUrl);
+        const before = new Set(this.explorBot.getCurrentPlan()?.tests ?? []);
         await this.explorBot.plan(feature, opts);
         if (this.explorBot.lastPlanError) {
-            tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
+            if (this.explorBot.lastPlanError instanceof ErrorPageError) {
+                throw this.explorBot.lastPlanError;
+            }
+            tag('info').log(`Retrying planning style '${opts.style}'...`);
+            if (pageUrl && !this.dryRun)
+                await this.explorBot.visit(pageUrl);
+            await this.explorBot.plan(feature, opts);
+            if (this.explorBot.lastPlanError) {
+                tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
+                return;
+            }
+        }
+        const planAfter = this.explorBot.getCurrentPlan();
+        if (!planAfter)
+            return;
+        const added = planAfter.tests.filter((t) => !before.has(t));
+        if (added.length === 0)
+            return;
+        const urlNote = pageUrl ? ` for ${pageUrl}` : '';
+        this.printPreview(`Planner added ${added.length} new test(s) [style=${opts.style}]${urlNote}:`, added);
+    }
+    parseConfigure(raw) {
+        const cfg = { enabled: false, newRatio: 1.0 };
+        if (!raw)
+            return cfg;
+        const allStyles = Object.keys(getStyles());
+        const validSubpages = new Set(['none', 'same', 'new', 'both']);
+        let hasReuseSignal = false;
+        for (const pair of raw.split(';')) {
+            const trimmed = pair.trim();
+            if (!trimmed)
+                continue;
+            const sepMatch = trimmed.match(/^([^:=]+)\s*[:=]\s*(.*)$/);
+            if (!sepMatch) {
+                tag('warning').log(`Ignoring malformed configure pair: ${trimmed}`);
+                continue;
+            }
+            const key = sepMatch[1].trim().toLowerCase();
+            const value = sepMatch[2].trim();
+            if (key === 'new') {
+                const ratio = parseRatio(value);
+                if (ratio == null) {
+                    tag('warning').log(`Ignoring invalid 'new' value: ${value}`);
+                    continue;
+                }
+                cfg.newRatio = ratio;
+                hasReuseSignal = true;
+                continue;
+            }
+            if (key === 'from') {
+                cfg.fromPath = value;
+                hasReuseSignal = true;
+                continue;
+            }
+            if (key === 'style' || key === 'styles') {
+                const requested = value
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+                const valid = [];
+                for (const s of requested) {
+                    if (allStyles.includes(s)) {
+                        valid.push(s);
+                        continue;
+                    }
+                    tag('warning').log(`Unknown planning style: ${s}`);
+                }
+                if (valid.length)
+                    cfg.styles = valid;
+                continue;
+            }
+            if (key === 'subpages') {
+                if (!validSubpages.has(value)) {
+                    tag('warning').log(`Ignoring invalid 'subpages' value: ${value}`);
+                    continue;
+                }
+                cfg.subpages = value;
+                continue;
+            }
+            if (key === 'pick_by' || key === 'pickby' || key === 'pick-by') {
+                if (value === 'priority' || value === 'random' || value === 'index') {
+                    cfg.pickBy = value;
+                    continue;
+                }
+                tag('warning').log(`Ignoring invalid 'pick_by' value: ${value} (use priority|random|index)`);
+                continue;
+            }
+            if (key === 'priority' || key === 'priorities') {
+                const requested = value
+                    .split(',')
+                    .map((s) => s.trim().toLowerCase())
+                    .filter(Boolean);
+                const valid = [];
+                for (const p of requested) {
+                    if (p in PRIORITY_ORDER) {
+                        valid.push(p);
+                        continue;
+                    }
+                    tag('warning').log(`Unknown priority: ${p} (use ${Object.keys(PRIORITY_ORDER).join('|')})`);
+                }
+                if (valid.length)
+                    cfg.priorities = valid;
+                continue;
+            }
+            tag('warning').log(`Unknown configure key: ${key}`);
         }
+        cfg.enabled = hasReuseSignal;
+        return cfg;
     }
     printResults() {
-        const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
+        const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title }))).sort((a, b) => (a.test.startTime ?? 0) - (b.test.startTime ?? 0));
         if (allTests.length === 0)
             return;
         const hasSubPages = this.completedPlans.length > 1;
+        const hasOrigin = this.oldTestRefs.size > 0;
         const rows = allTests.map(({ test, planTitle }, index) => {
             const durationMs = test.getDurationMs();
             const duration = durationMs != null ? `${(durationMs / 1000).toFixed(1)}s` : '-';
@@ -127,12 +408,17 @@ export class ExploreCommand extends BaseCommand {
                 Time: duration,
                 Steps: String(Object.keys(test.notes).length),
             };
+            if (hasOrigin) {
+                row.Origin = this.originLabel(test);
+            }
             if (hasSubPages) {
                 row.Plan = planTitle;
             }
             return row;
         });
         const columns = ['#', 'Status', 'Title', 'Priority', 'Time', 'Steps'];
+        if (hasOrigin)
+            columns.push('Origin');
         if (hasSubPages)
             columns.push('Plan');
         tag('multiline').log(jsonToTable(rows, columns));
@@ -185,11 +471,41 @@ export class ExploreCommand extends BaseCommand {
         const plan = this.explorBot.getCurrentPlan();
         if (!plan)
             return;
+        if (this.priorityFilter) {
+            for (const t of plan.getPendingTests()) {
+                if (!this.priorityFilter.has(t.priority))
+                    t.enabled = false;
+            }
+        }
         for (const test of plan.getPendingTests()) {
             if (this.isLimitReached())
                 break;
+            await this.runOneTest(test);
+        }
+    }
+    async runOneTest(test) {
+        if (this.dryRun) {
+            test.start();
+            test.finish(TestResult.SKIPPED);
+        }
+        else {
             await this.explorBot.agentTester().test(test);
-            this.testsRun++;
         }
+        this.testsRun++;
+    }
+}
+function parseRatio(s) {
+    const trimmed = s.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.endsWith('%')) {
+        const n = Number.parseFloat(trimmed.slice(0, -1));
+        if (Number.isNaN(n) || n < 0 || n > 100)
+            return null;
+        return n / 100;
     }
+    const n = Number.parseFloat(trimmed);
+    if (Number.isNaN(n) || n < 0 || n > 1)
+        return null;
+    return n;
 }

package/dist/src/explorbot.js

@@ -24,6 +24,7 @@ import { ExperienceTracker } from "./experience-tracker.js";
 import Explorer from "./explorer.js";
 import { KnowledgeTracker } from "./knowledge-tracker.js";
 import { Plan } from "./test-plan.js";
+import { parsePlansFromMarkdown } from "./utils/test-plan-markdown.js";
 import { setVerboseMode, tag } from "./utils/logger.js";
 import { relativeToCwd } from "./utils/next-steps.js";
 import { sanitizeFilename } from "./utils/strings.js";
@@ -323,7 +324,8 @@ export class ExplorBot {
                 return undefined;
             return this.currentPlan;
         }
-        this.savePlan();
+        if (!opts.noSave)
+            this.savePlan();
         return this.currentPlan;
     }
     getPlansDir() {
@@ -348,20 +350,21 @@ export class ExplorBot {
         this.lastSavedPlanPath = planPath;
         return planPath;
     }
-    generatePlanFilename() {
+    generatePlanFilename(feature) {
         const state = this.explorer?.getStateManager().getCurrentState();
         const urlPath = state?.url || '/';
         const urlPart = sanitizeFilename(urlPath) || 'root';
         const suffix = '.md';
-        if (!this.planFeature)
+        const f = feature ?? this.planFeature;
+        if (!f)
             return urlPart.slice(0, 256 - suffix.length) + suffix;
-        const featurePart = `_${sanitizeFilename(this.planFeature)}`;
+        const featurePart = `_${sanitizeFilename(f)}`;
         const maxFeatureLen = 256 - suffix.length - urlPart.length;
         if (maxFeatureLen <= 1)
             return urlPart.slice(0, 256 - suffix.length) + suffix;
         return urlPart + featurePart.slice(0, maxFeatureLen) + suffix;
     }
-    loadPlan(filename) {
+    resolvePlanPath(filename) {
         let planPath = filename;
         if (path.isAbsolute(filename)) {
             if (!existsSync(planPath) && !filename.endsWith('.md')) {
@@ -378,12 +381,23 @@ export class ExplorBot {
                 planPath = path.join(plansDir, `${filename}.md`);
             }
         }
+        return planPath;
+    }
+    loadPlan(filename) {
+        const planPath = this.resolvePlanPath(filename);
         if (!existsSync(planPath)) {
             throw new Error(`Plan file not found: ${planPath}`);
         }
         this.setCurrentPlan(Plan.fromMarkdown(planPath));
         return this.currentPlan;
     }
+    loadPlans(filename) {
+        const planPath = this.resolvePlanPath(filename);
+        if (!existsSync(planPath)) {
+            throw new Error(`Plan file not found: ${planPath}`);
+        }
+        return parsePlansFromMarkdown(planPath);
+    }
     setCurrentPlan(plan) {
         this.currentPlan = plan;
         if (plan && !this.sessionPlans.includes(plan)) {

package/dist/src/utils/test-plan-markdown.js

@@ -145,8 +145,15 @@ export function parsePlansFromMarkdown(filePath) {
             continue;
         if (line.startsWith('<!-- test')) {
             currentTest = null;
-            const priorityMatch = line.match(/priority:\s*(\w+)/);
+            let block = line;
+            let j = i;
+            while (!block.includes('-->') && j + 1 < lines.length) {
+                j++;
+                block += `\n${lines[j].trim()}`;
+            }
+            const priorityMatch = block.match(/priority:\s*(\w+)/);
             priority = priorityMatch?.[1] || 'normal';
+            i = j;
             continue;
         }
         if (line.startsWith('# ') && currentTest === null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",

package/src/ai/pilot.ts

@@ -320,14 +320,9 @@ export class Pilot implements Agent {
       - "Edit X" → updated value must be persisted (visible in list/detail). Opening edit is NOT enough; redirect after save with the new value visible IS enough.
       - Negative tests ("without a name", "invalid", "duplicate", "unauthorized") → success means the system PREVENTED the action with validation/error.
 
-      PROVENANCE for create/edit scenarios: the task prompt instructs the tester to inject the
-      session marker "${task.sessionName ?? ''}" into newly created or edited free-text values.
-      When that marker COULD be injected, the entity used as proof MUST contain it. A record
-      matching the goal by text alone but missing the marker is a stale leftover from a prior
-      run — it is NOT evidence the current scenario produced anything. Vote \`fail\`, not \`pass\`.
-      This does not apply when the field is restricted (numeric only, enum, etc.) or when the
-      session_log shows no fillField/type/select actions were attempted at all (in that case
-      the scenario clearly didn't run — also vote \`fail\`).
+      PROVENANCE: the entity you cite as proof must appear by name in <notes> or
+      <session_log> tool inputs for THIS run. Name absent from tester activity = stale
+      coincidence, vote \`fail\`. Same if no fillField/type/select/click on a target ran.
 
       Expected results are MILESTONES, not the goal. Never fail because a milestone (toast, icon, styling)
       didn't match if the scenario goal IS accomplished.

package/src/ai/tester.ts

@@ -730,6 +730,7 @@ export class Tester extends TaskAgent implements Agent {
     - Use pressKey() for pressing special keys (Enter, Escape, Tab, Arrow keys) or key combinations with modifiers (Ctrl+A, Shift+Delete, etc.)
     - Use container CSS locators from <page_ui_map> to interact with elements inside sections
     - Systematically use record({ notes: ["..."] }) to write your findings, planned actions, observations, etc.
+    - When creating/editing/deleting a named entity, include its identifier verbatim in the note — Pilot uses it to confirm provenance.
     - Call record({ notes: ["..."], status: "success" }) when you see success/info message on a page or when expected outcome is achieved
     - Call record({ notes: ["..."], status: "fail" }) when an expected outcome cannot be achieved or has failed or you see error/alert/warning message on a page
     - NEVER call record(status: "success") if your last verify() or see() call FAILED. A failed check means the outcome is NOT confirmed — use record(status: "fail") instead, or retry with a different approach.

package/src/commands/explore-command.ts

@@ -3,7 +3,7 @@ import { getStyles } from '../ai/planner/styles.js';
 import { outputPath } from '../config.js';
 import { normalizeUrl } from '../state-manager.js';
 import { Stats } from '../stats.js';
-import type { Plan } from '../test-plan.js';
+import { type Plan, type Test, TestResult } from '../test-plan.js';
 import { getCliName } from '../utils/cli-name.ts';
 import { ErrorPageError } from '../utils/error-page.ts';
 import { tag } from '../utils/logger.js';
@@ -13,6 +13,7 @@ import { safeFilename } from '../utils/strings.ts';
 import { BaseCommand, type Suggestion } from './base-command.js';
 
 const MAX_SUB_PAGE_ATTEMPTS = 30;
+const PRIORITY_ORDER: Record<string, number> = { critical: 0, important: 1, high: 2, normal: 3, low: 4 };
 
 export class ExploreCommand extends BaseCommand {
   name = 'explore';
@@ -20,6 +21,8 @@ export class ExploreCommand extends BaseCommand {
   options = [
     { flags: '--max-tests <number>', description: 'Maximum number of tests to run' },
     { flags: '--focus <feature>', description: 'Focus area for exploration' },
+    { flags: '--configure <spec>', description: 'Reuse spec: keys new|from|style|subpages|pick_by|priority, e.g. "new:25%;pick_by=random;priority=critical,high"' },
+    { flags: '--dry-run', description: 'Mark picked tests as skipped without executing or generating new ones' },
   ];
   suggestions: Suggestion[] = [
     { command: 'navigate <page>', hint: 'go to another page' },
@@ -28,9 +31,12 @@ export class ExploreCommand extends BaseCommand {
   ];
 
   maxTests?: number;
+  dryRun = false;
   private testsRun = 0;
   private completedPlans: Plan[] = [];
   private failedSubPages = new Set<string>();
+  private oldTestRefs = new Set<Test>();
+  private priorityFilter?: Set<string>;
 
   async execute(args: string): Promise<void> {
     const { opts, args: remaining } = this.parseArgs(args);
@@ -39,86 +45,359 @@ export class ExploreCommand extends BaseCommand {
     }
 
     const feature = (opts.focus as string) || remaining.join(' ') || undefined;
+    const cfg = this.parseConfigure(opts.configure as string | undefined);
+    if (cfg.priorities) this.priorityFilter = new Set(cfg.priorities);
+    if (opts.dryRun) this.dryRun = true;
+    if (this.dryRun) tag('info').log('Dry-run mode: planner runs to discover new tests; test execution is skipped');
     Stats.mode ??= 'explore';
     Stats.focus ??= feature;
     const mainUrl = this.explorBot.getExplorer().getStateManager().getCurrentState()?.url;
 
-    await this.runAllStyles(mainUrl, feature);
+    if (cfg.enabled) {
+      await this.runReuseMode(mainUrl, feature, cfg);
+    } else {
+      await this.runFreshMode(mainUrl, feature, cfg.styles);
+    }
+
+    const mainPlan = this.completedPlans[0];
+    if (mainPlan) this.explorBot.setCurrentPlan(mainPlan);
+    if (this.dryRun) {
+      this.printResults();
+      return;
+    }
+    if (mainUrl) await this.explorBot.visit(mainUrl);
+    const savedPath = this.explorBot.savePlans(this.completedPlans);
+    this.printResults();
+    await this.explorBot.printSessionAnalysis();
+    this.printNextSteps(savedPath);
+  }
+
+  private originLabel(test: Test): string {
+    return this.oldTestRefs.has(test) ? 'OLD' : 'NEW';
+  }
+
+  private printPreview(label: string, tests: Test[]): void {
+    if (tests.length === 0) return;
+    const lines = [label];
+    for (let i = 0; i < tests.length; i++) {
+      const t = tests[i];
+      lines.push(`  ${String(i + 1).padStart(2)}. [${this.originLabel(t)}] [${t.priority.padEnd(9)}] ${t.scenario}`);
+    }
+    tag('multiline').log(lines.join('\n'));
+  }
+
+  private async runFreshMode(mainUrl: string | undefined, feature: string | undefined, styles?: string[]): Promise<void> {
+    await this.runAllStyles(mainUrl, feature, undefined, undefined, styles);
     const mainPlan = this.explorBot.getCurrentPlan();
     if (!mainPlan) return;
     this.completedPlans.push(mainPlan);
 
-    if (!feature && !this.isLimitReached()) {
-      const planner = this.explorBot.agentPlanner();
-      let attempts = 0;
-      while (attempts < MAX_SUB_PAGE_ATTEMPTS) {
-        attempts++;
-        if (this.isLimitReached()) break;
+    if (feature || this.isLimitReached()) return;
+
+    await this.discoverNewSubPages(mainPlan, mainUrl, styles, new Set());
+  }
+
+  private async runReuseMode(mainUrl: string | undefined, feature: string | undefined, cfg: ConfigureSpec): Promise<void> {
+    const filename = cfg.fromPath || this.explorBot.generatePlanFilename(feature);
+
+    let loadedPlans: Plan[] = [];
+    try {
+      loadedPlans = this.explorBot.loadPlans(filename);
+    } catch (err) {
+      tag('warning').log(`Reuse plan not found (${err instanceof Error ? err.message : err}); falling back to fresh planning`);
+      await this.runFreshMode(mainUrl, feature, cfg.styles);
+      return;
+    }
 
-        const candidates = planner.collectSubPageCandidates(mainPlan, mainUrl || '/').filter((c) => !this.failedSubPages.has(normalizeUrl(c.url)));
-        if (candidates.length === 0) break;
+    if (loadedPlans.length === 0) {
+      tag('warning').log('Reuse plan empty; falling back to fresh planning');
+      await this.runFreshMode(mainUrl, feature, cfg.styles);
+      return;
+    }
+
+    const mainPlan = loadedPlans[0];
+    const subPlans = loadedPlans.slice(1);
 
-        const pick = await planner.pickNextSubPage(candidates);
-        if (!pick) break;
+    const totalCap = this.maxTests ?? Number.POSITIVE_INFINITY;
+    let newQuota = Number.POSITIVE_INFINITY;
+    let oldQuota = Number.POSITIVE_INFINITY;
+    if (Number.isFinite(totalCap)) {
+      newQuota = Math.round(totalCap * cfg.newRatio);
+      oldQuota = Math.max(0, totalCap - newQuota);
+    }
 
-        tag('info').log(`Exploring sub-page: ${pick.url} (${pick.reason})`);
+    for (const p of loadedPlans) {
+      for (const t of p.tests) this.oldTestRefs.add(t);
+    }
+
+    const allOldTests = loadedPlans.flatMap((p) => p.tests.filter((t) => t.status === 'pending'));
+    let matchingOldTests: Test[] = allOldTests;
+    if (cfg.styles) {
+      matchingOldTests = matchingOldTests.filter((t) => !t.style || cfg.styles!.includes(t.style));
+    }
+    if (this.priorityFilter) {
+      matchingOldTests = matchingOldTests.filter((t) => this.priorityFilter!.has(t.priority));
+    }
+    const pickBy = cfg.pickBy ?? 'priority';
+    const orderedOldTests = matchingOldTests.slice();
+    if (pickBy === 'priority') {
+      orderedOldTests.sort((a, b) => (PRIORITY_ORDER[a.priority] ?? 99) - (PRIORITY_ORDER[b.priority] ?? 99));
+    } else if (pickBy === 'random') {
+      for (let i = orderedOldTests.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [orderedOldTests[i], orderedOldTests[j]] = [orderedOldTests[j], orderedOldTests[i]];
+      }
+    }
+
+    let pickCount = orderedOldTests.length;
+    if (Number.isFinite(oldQuota)) pickCount = Math.min(oldQuota, orderedOldTests.length);
+    const picked = orderedOldTests.slice(0, pickCount);
+    const pickedSet = new Set(picked);
+
+    for (const t of allOldTests) {
+      if (!pickedSet.has(t)) t.enabled = false;
+    }
+
+    let newQuotaLabel = 'unlimited';
+    if (Number.isFinite(newQuota)) newQuotaLabel = String(newQuota);
+    let priorityNote = '';
+    if (this.priorityFilter) priorityNote = `, priority=[${[...this.priorityFilter].join(',')}]`;
+    tag('info').log(`Reuse: loaded ${allOldTests.length} old test(s), running ${picked.length} (pick_by=${pickBy}${priorityNote}), reserving ${newQuotaLabel} for new`);
+
+    const planner = this.explorBot.agentPlanner();
+    for (const p of loadedPlans) planner.registerPlanInSession(p);
+
+    this.completedPlans.push(...loadedPlans);
+
+    this.printPreview(`Picked old tests (${picked.length}):`, picked);
+
+    let currentPlanRef: Plan | undefined;
+    for (const test of picked) {
+      if (this.isLimitReached()) break;
+      const owningPlan = test.plan;
+      if (owningPlan && owningPlan !== currentPlanRef) {
+        this.explorBot.setCurrentPlan(owningPlan);
+        if (owningPlan.url && !this.dryRun) await this.explorBot.visit(owningPlan.url);
+        currentPlanRef = owningPlan;
+      }
+      await this.runOneTest(test);
+    }
+
+    if (this.isLimitReached() || newQuota <= 0) return;
+
+    const subpagesMode = cfg.subpages || 'both';
+
+    if (mainUrl && !this.dryRun) await this.explorBot.visit(mainUrl);
+    await this.replanAndRun(mainUrl, feature, mainPlan, cfg.styles);
+
+    if (this.isLimitReached()) return;
+
+    if (subpagesMode === 'same' || subpagesMode === 'both') {
+      for (const subPlan of subPlans) {
+        if (this.isLimitReached()) break;
+        if (!subPlan.url) continue;
         try {
-          await this.explorBot.visit(pick.url);
-          await this.runAllStyles(pick.url, undefined, mainPlan, this.completedPlans);
-          const subPlan = this.explorBot.getCurrentPlan();
-          if (subPlan) {
-            this.completedPlans.push(subPlan);
-          }
+          if (!this.dryRun) await this.explorBot.visit(subPlan.url);
+          await this.replanAndRun(subPlan.url, undefined, subPlan, cfg.styles);
         } catch (err) {
-          this.failedSubPages.add(normalizeUrl(pick.url));
-          tag('warning').log(`Sub-page exploration failed: ${err instanceof Error ? err.message : err}`);
+          this.failedSubPages.add(normalizeUrl(subPlan.url));
+          tag('warning').log(`Sub-page re-planning failed: ${err instanceof Error ? err.message : err}`);
         }
       }
     }
 
-    this.explorBot.setCurrentPlan(mainPlan);
-    if (mainUrl) await this.explorBot.visit(mainUrl);
-    const savedPath = this.explorBot.savePlans(this.completedPlans);
-    this.printResults();
-    await this.explorBot.printSessionAnalysis();
-    this.printNextSteps(savedPath);
+    if (this.isLimitReached()) return;
+
+    if (subpagesMode === 'new' || subpagesMode === 'both') {
+      const knownUrls = new Set<string>();
+      for (const p of loadedPlans) {
+        if (p.url) knownUrls.add(normalizeUrl(p.url));
+      }
+      await this.discoverNewSubPages(mainPlan, mainUrl, cfg.styles, knownUrls);
+    }
+  }
+
+  private async discoverNewSubPages(mainPlan: Plan, mainUrl: string | undefined, styles: string[] | undefined, knownUrls: Set<string>): Promise<void> {
+    const planner = this.explorBot.agentPlanner();
+    let attempts = 0;
+    while (attempts < MAX_SUB_PAGE_ATTEMPTS) {
+      attempts++;
+      if (this.isLimitReached()) break;
+
+      const candidates = planner.collectSubPageCandidates(mainPlan, mainUrl || '/').filter((c) => {
+        const norm = normalizeUrl(c.url);
+        return !this.failedSubPages.has(norm) && !knownUrls.has(norm);
+      });
+      if (candidates.length === 0) break;
+
+      const pick = await planner.pickNextSubPage(candidates);
+      if (!pick) break;
+
+      tag('info').log(`Exploring sub-page: ${pick.url} (${pick.reason})`);
+      try {
+        await this.explorBot.visit(pick.url);
+        await this.runAllStyles(pick.url, undefined, mainPlan, this.completedPlans, styles);
+        const subPlan = this.explorBot.getCurrentPlan();
+        if (subPlan && !this.completedPlans.includes(subPlan)) {
+          this.completedPlans.push(subPlan);
+        }
+        knownUrls.add(normalizeUrl(pick.url));
+      } catch (err) {
+        this.failedSubPages.add(normalizeUrl(pick.url));
+        tag('warning').log(`Sub-page exploration failed: ${err instanceof Error ? err.message : err}`);
+      }
+    }
   }
 
-  private async runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[]): Promise<void> {
+  private async replanAndRun(pageUrl: string | undefined, feature: string | undefined, existingPlan: Plan, styles?: string[]): Promise<void> {
+    const styleList = styles ?? Object.keys(getStyles());
+    for (const style of styleList) {
+      if (this.isLimitReached()) break;
+      this.explorBot.setCurrentPlan(existingPlan);
+      const opts: { fresh: boolean; style: string; completedPlans?: Plan[]; noSave?: boolean } = { fresh: false, style, completedPlans: this.completedPlans };
+      if (this.dryRun) opts.noSave = true;
+      await this.planWithRetry(feature, opts, pageUrl);
+      await this.runPendingTests();
+    }
+  }
+
+  private async runAllStyles(pageUrl?: string, feature?: string, parentPlan?: Plan, completedPlans?: Plan[], styles?: string[]): Promise<void> {
+    const styleList = styles ?? Object.keys(getStyles());
     let fresh = true;
-    for (const style of Object.keys(getStyles())) {
-      if (!fresh && pageUrl) {
+    for (const style of styleList) {
+      if (!fresh && pageUrl && !this.dryRun) {
         await this.explorBot.visit(pageUrl);
       }
-      const opts: { fresh: boolean; style: string; extend?: Plan; completedPlans?: Plan[] } = { fresh, style, completedPlans };
+      const opts: { fresh: boolean; style: string; extend?: Plan; completedPlans?: Plan[]; noSave?: boolean } = { fresh, style, completedPlans };
       if (fresh && parentPlan) opts.extend = parentPlan;
+      if (this.dryRun) opts.noSave = true;
       await this.planWithRetry(feature, opts, pageUrl);
       await this.runPendingTests();
       fresh = false;
     }
   }
 
-  private async planWithRetry(feature: string | undefined, opts: { fresh: boolean; style: string; extend?: Plan; completedPlans?: Plan[] }, pageUrl?: string): Promise<void> {
-    await this.explorBot.plan(feature, opts);
-    if (!this.explorBot.lastPlanError) return;
-    if (this.explorBot.lastPlanError instanceof ErrorPageError) {
-      throw this.explorBot.lastPlanError;
-    }
+  private async planWithRetry(feature: string | undefined, opts: { fresh: boolean; style: string; extend?: Plan; completedPlans?: Plan[]; noSave?: boolean }, pageUrl?: string): Promise<void> {
+    const before = new Set(this.explorBot.getCurrentPlan()?.tests ?? []);
 
-    tag('info').log(`Retrying planning style '${opts.style}'...`);
-    if (pageUrl) await this.explorBot.visit(pageUrl);
     await this.explorBot.plan(feature, opts);
     if (this.explorBot.lastPlanError) {
-      tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
+      if (this.explorBot.lastPlanError instanceof ErrorPageError) {
+        throw this.explorBot.lastPlanError;
+      }
+      tag('info').log(`Retrying planning style '${opts.style}'...`);
+      if (pageUrl && !this.dryRun) await this.explorBot.visit(pageUrl);
+      await this.explorBot.plan(feature, opts);
+      if (this.explorBot.lastPlanError) {
+        tag('warning').log(`Planning style '${opts.style}' failed after retry, skipping`);
+        return;
+      }
+    }
+
+    const planAfter = this.explorBot.getCurrentPlan();
+    if (!planAfter) return;
+    const added = planAfter.tests.filter((t) => !before.has(t));
+    if (added.length === 0) return;
+    const urlNote = pageUrl ? ` for ${pageUrl}` : '';
+    this.printPreview(`Planner added ${added.length} new test(s) [style=${opts.style}]${urlNote}:`, added);
+  }
+
+  private parseConfigure(raw: string | undefined): ConfigureSpec {
+    const cfg: ConfigureSpec = { enabled: false, newRatio: 1.0 };
+    if (!raw) return cfg;
+
+    const allStyles = Object.keys(getStyles());
+    const validSubpages = new Set(['none', 'same', 'new', 'both']);
+    let hasReuseSignal = false;
+
+    for (const pair of raw.split(';')) {
+      const trimmed = pair.trim();
+      if (!trimmed) continue;
+      const sepMatch = trimmed.match(/^([^:=]+)\s*[:=]\s*(.*)$/);
+      if (!sepMatch) {
+        tag('warning').log(`Ignoring malformed configure pair: ${trimmed}`);
+        continue;
+      }
+      const key = sepMatch[1].trim().toLowerCase();
+      const value = sepMatch[2].trim();
+
+      if (key === 'new') {
+        const ratio = parseRatio(value);
+        if (ratio == null) {
+          tag('warning').log(`Ignoring invalid 'new' value: ${value}`);
+          continue;
+        }
+        cfg.newRatio = ratio;
+        hasReuseSignal = true;
+        continue;
+      }
+      if (key === 'from') {
+        cfg.fromPath = value;
+        hasReuseSignal = true;
+        continue;
+      }
+      if (key === 'style' || key === 'styles') {
+        const requested = value
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean);
+        const valid: string[] = [];
+        for (const s of requested) {
+          if (allStyles.includes(s)) {
+            valid.push(s);
+            continue;
+          }
+          tag('warning').log(`Unknown planning style: ${s}`);
+        }
+        if (valid.length) cfg.styles = valid;
+        continue;
+      }
+      if (key === 'subpages') {
+        if (!validSubpages.has(value)) {
+          tag('warning').log(`Ignoring invalid 'subpages' value: ${value}`);
+          continue;
+        }
+        cfg.subpages = value as ConfigureSpec['subpages'];
+        continue;
+      }
+      if (key === 'pick_by' || key === 'pickby' || key === 'pick-by') {
+        if (value === 'priority' || value === 'random' || value === 'index') {
+          cfg.pickBy = value;
+          continue;
+        }
+        tag('warning').log(`Ignoring invalid 'pick_by' value: ${value} (use priority|random|index)`);
+        continue;
+      }
+      if (key === 'priority' || key === 'priorities') {
+        const requested = value
+          .split(',')
+          .map((s) => s.trim().toLowerCase())
+          .filter(Boolean);
+        const valid: string[] = [];
+        for (const p of requested) {
+          if (p in PRIORITY_ORDER) {
+            valid.push(p);
+            continue;
+          }
+          tag('warning').log(`Unknown priority: ${p} (use ${Object.keys(PRIORITY_ORDER).join('|')})`);
+        }
+        if (valid.length) cfg.priorities = valid;
+        continue;
+      }
+      tag('warning').log(`Unknown configure key: ${key}`);
     }
+
+    cfg.enabled = hasReuseSignal;
+    return cfg;
   }
 
   private printResults(): void {
-    const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title })));
+    const allTests = this.completedPlans.flatMap((plan) => plan.tests.filter((t) => t.startTime != null).map((test) => ({ test, planTitle: plan.title }))).sort((a, b) => (a.test.startTime ?? 0) - (b.test.startTime ?? 0));
 
     if (allTests.length === 0) return;
 
     const hasSubPages = this.completedPlans.length > 1;
+    const hasOrigin = this.oldTestRefs.size > 0;
     const rows = allTests.map(({ test, planTitle }, index) => {
       const durationMs = test.getDurationMs();
       const duration = durationMs != null ? `${(durationMs / 1000).toFixed(1)}s` : '-';
@@ -133,12 +412,16 @@ export class ExploreCommand extends BaseCommand {
         Time: duration,
         Steps: String(Object.keys(test.notes).length),
       };
+      if (hasOrigin) {
+        row.Origin = this.originLabel(test);
+      }
       if (hasSubPages) {
         row.Plan = planTitle;
       }
       return row;
     });
     const columns = ['#', 'Status', 'Title', 'Priority', 'Time', 'Steps'];
+    if (hasOrigin) columns.push('Origin');
     if (hasSubPages) columns.push('Plan');
     tag('multiline').log(jsonToTable(rows, columns));
     tag('info').log(`${figureSet.tick} ${allTests.length} tests completed`);
@@ -197,10 +480,47 @@ export class ExploreCommand extends BaseCommand {
   private async runPendingTests(): Promise<void> {
     const plan = this.explorBot.getCurrentPlan();
     if (!plan) return;
+    if (this.priorityFilter) {
+      for (const t of plan.getPendingTests()) {
+        if (!this.priorityFilter.has(t.priority)) t.enabled = false;
+      }
+    }
     for (const test of plan.getPendingTests()) {
       if (this.isLimitReached()) break;
+      await this.runOneTest(test);
+    }
+  }
+
+  private async runOneTest(test: Test): Promise<void> {
+    if (this.dryRun) {
+      test.start();
+      test.finish(TestResult.SKIPPED);
+    } else {
       await this.explorBot.agentTester().test(test);
-      this.testsRun++;
     }
+    this.testsRun++;
+  }
+}
+
+interface ConfigureSpec {
+  enabled: boolean;
+  newRatio: number;
+  fromPath?: string;
+  styles?: string[];
+  subpages?: 'none' | 'same' | 'new' | 'both';
+  pickBy?: 'priority' | 'random' | 'index';
+  priorities?: string[];
+}
+
+function parseRatio(s: string): number | null {
+  const trimmed = s.trim();
+  if (!trimmed) return null;
+  if (trimmed.endsWith('%')) {
+    const n = Number.parseFloat(trimmed.slice(0, -1));
+    if (Number.isNaN(n) || n < 0 || n > 100) return null;
+    return n / 100;
   }
+  const n = Number.parseFloat(trimmed);
+  if (Number.isNaN(n) || n < 0 || n > 1) return null;
+  return n;
 }

package/src/explorbot.ts

@@ -27,6 +27,7 @@ import { KnowledgeTracker } from './knowledge-tracker.ts';
 import { WebPageState } from './state-manager.ts';
 import type { Suite } from './suite.ts';
 import { Plan, type Test } from './test-plan.ts';
+import { parsePlansFromMarkdown } from './utils/test-plan-markdown.ts';
 import { setVerboseMode, tag } from './utils/logger.ts';
 import { relativeToCwd } from './utils/next-steps.ts';
 import { sanitizeFilename } from './utils/strings.ts';
@@ -349,7 +350,7 @@ export class ExplorBot {
     this.agents.planner = undefined;
   }
 
-  async plan(feature?: string, opts: { fresh?: boolean; style?: string; extend?: Plan; completedPlans?: Plan[] } = {}) {
+  async plan(feature?: string, opts: { fresh?: boolean; style?: string; extend?: Plan; completedPlans?: Plan[]; noSave?: boolean } = {}) {
     this.planFeature = feature;
 
     if (opts.fresh) {
@@ -379,7 +380,7 @@ export class ExplorBot {
       return this.currentPlan;
     }
 
-    this.savePlan();
+    if (!opts.noSave) this.savePlan();
 
     return this.currentPlan;
   }
@@ -409,19 +410,20 @@ export class ExplorBot {
     return planPath;
   }
 
-  generatePlanFilename(): string {
+  generatePlanFilename(feature?: string): string {
     const state = this.explorer?.getStateManager().getCurrentState();
     const urlPath = state?.url || '/';
     const urlPart = sanitizeFilename(urlPath) || 'root';
     const suffix = '.md';
-    if (!this.planFeature) return urlPart.slice(0, 256 - suffix.length) + suffix;
-    const featurePart = `_${sanitizeFilename(this.planFeature)}`;
+    const f = feature ?? this.planFeature;
+    if (!f) return urlPart.slice(0, 256 - suffix.length) + suffix;
+    const featurePart = `_${sanitizeFilename(f)}`;
     const maxFeatureLen = 256 - suffix.length - urlPart.length;
     if (maxFeatureLen <= 1) return urlPart.slice(0, 256 - suffix.length) + suffix;
     return urlPart + featurePart.slice(0, maxFeatureLen) + suffix;
   }
 
-  loadPlan(filename: string): Plan {
+  resolvePlanPath(filename: string): string {
     let planPath = filename;
 
     if (path.isAbsolute(filename)) {
@@ -438,14 +440,26 @@ export class ExplorBot {
       }
     }
 
+    return planPath;
+  }
+
+  loadPlan(filename: string): Plan {
+    const planPath = this.resolvePlanPath(filename);
     if (!existsSync(planPath)) {
       throw new Error(`Plan file not found: ${planPath}`);
     }
-
     this.setCurrentPlan(Plan.fromMarkdown(planPath));
     return this.currentPlan!;
   }
 
+  loadPlans(filename: string): Plan[] {
+    const planPath = this.resolvePlanPath(filename);
+    if (!existsSync(planPath)) {
+      throw new Error(`Plan file not found: ${planPath}`);
+    }
+    return parsePlansFromMarkdown(planPath);
+  }
+
   setCurrentPlan(plan?: Plan): void {
     this.currentPlan = plan;
     if (plan && !this.sessionPlans.includes(plan)) {

package/src/utils/test-plan-markdown.ts

@@ -149,8 +149,15 @@ export function parsePlansFromMarkdown(filePath: string): Plan[] {
 
     if (line.startsWith('<!-- test')) {
       currentTest = null;
-      const priorityMatch = line.match(/priority:\s*(\w+)/);
+      let block = line;
+      let j = i;
+      while (!block.includes('-->') && j + 1 < lines.length) {
+        j++;
+        block += `\n${lines[j].trim()}`;
+      }
+      const priorityMatch = block.match(/priority:\s*(\w+)/);
       priority = (priorityMatch?.[1] as 'critical' | 'important' | 'high' | 'normal' | 'low') || 'normal';
+      i = j;
       continue;
     }