explorbot 0.1.15 → 0.1.17

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