explorbot 0.1.16 → 0.1.18

package/dist/src/utils/url-matcher.js

@@ -90,11 +90,13 @@ export function matchesUrl(pattern, path) {
     }
 }
 export function extractStatePath(url) {
-    if (url.startsWith('/'))
-        return url;
+    if (url.startsWith('/')) {
+        return `/${url.replace(/^\/+/, '')}`;
+    }
     try {
         const urlObj = new URL(url);
-        return `${urlObj.pathname}${urlObj.search}${urlObj.hash}`;
+        const normalizedPathname = `/${urlObj.pathname.replace(/^\/+/, '')}`;
+        return `${normalizedPathname}${urlObj.search}${urlObj.hash}`;
     }
     catch {
         return url;

package/dist/src/utils/web-element.js

@@ -109,7 +109,8 @@ export class WebElement {
         return WebElement.fromPlaywrightLocator(page.locator(`[${EXPLORBOT_ATTRS.eidx}="${eidx}"]`));
     }
     static async fromEidxList(page, eidxList) {
-        if (eidxList.length === 0)
+        const validEidxList = eidxList.filter((eidx) => /^e\d+$/i.test(eidx));
+        if (validEidxList.length === 0)
             return [];
         const rawList = await page.evaluate(([list, extractFnStr, config]) => {
             const extract = new Function(`return ${extractFnStr}`)();
@@ -123,7 +124,7 @@ export class WebElement {
                     results.push(data);
             }
             return results;
-        }, [eidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
+        }, [validEidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
         return rawList.map((d) => WebElement.fromRawData(d));
     }
     static async findByXPath(html, xpath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -20,6 +20,9 @@
     "src/**/*.tsx",
     "bin/**/*.ts",
     "boat/api-tester/src/**/*.ts",
+    "boat/doc-collector/src/**/*.ts",
+    "boat/doc-collector/bin/**/*.ts",
+    "boat/doc-collector/package.json",
     "rules/",
     "assets/sample-files/"
   ],

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/researcher/coordinates.ts

@@ -198,7 +198,7 @@ export function WithCoordinates<T extends Constructor>(Base: T) {
       const eidxWithoutCoords: string[] = [];
       for (const section of sections) {
         for (const el of section.elements) {
-          if (el.eidx && !el.coordinates) eidxWithoutCoords.push(el.eidx);
+          if (el.eidx && /^e\d+$/i.test(el.eidx) && !el.coordinates) eidxWithoutCoords.push(el.eidx);
         }
       }
       if (eidxWithoutCoords.length === 0) return;

package/src/ai/researcher/parser.ts

@@ -64,6 +64,9 @@ export function mapRowToElement(row: Record<string, string>): ResearchElement |
 
   let eidxRaw = (colMap.eidx || '').trim();
   if (eidxRaw && /^\d+$/.test(eidxRaw)) eidxRaw = `e${eidxRaw}`;
+  if (eidxRaw && !/^e\d+$/i.test(eidxRaw)) {
+    eidxRaw = '';
+  }
 
   const aria = parseAriaLocator(colMap.aria || '-');
 

package/src/ai/researcher.ts

@@ -121,7 +121,8 @@ export class Researcher extends ResearcherBase implements Agent {
 
     const sessionName = `researcher: ${state.url}`;
     return Observability.run(sessionName, { tags: ['researcher'], sessionId: stateHash }, async () => {
-      tag('info').log(`Researching ${state.url} to understand the context...`);
+      const displayUrl = state.fullUrl || state.url;
+      tag('info').log(`Researching ${displayUrl} to understand the context...`);
       setActivity(`${this.emoji} Researching...`, 'action');
 
       await this.ensureNavigated(state.url, screenshot && this.provider.hasVision());

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;
 }