explorbot 0.5.10 → 0.6.0

package/dist/src/components/InputPane.js

@@ -7,7 +7,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
     const [cursorPosition, setCursorPosition] = useState(0);
     const [showAutocomplete, setShowAutocomplete] = useState(false);
     const [selectedIndex, setSelectedIndex] = useState(0);
-    const [autoCompleteTriggered, setAutoCompleteTriggered] = useState(false);
     const inputRef = useRef(inputValue);
     const cursorRef = useRef(cursorPosition);
     const addLog = useCallback((entry) => {
@@ -137,7 +136,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
                 setShowAutocomplete(false);
                 setSelectedIndex(0);
                 setCursorPosition(selectedCommand.length);
-                setAutoCompleteTriggered(true);
             }
             return;
         }
@@ -152,7 +150,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
                 setInputValue(newValue);
                 setCursorPosition(nextCursor);
                 setSelectedIndex(0);
-                setAutoCompleteTriggered(false);
                 setShowAutocomplete(shouldShowAutocomplete(newValue));
             }
             return;
@@ -167,7 +164,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
             setInputValue(newValue);
             setCursorPosition(nextCursor);
             setSelectedIndex(0);
-            setAutoCompleteTriggered(false);
             setShowAutocomplete(shouldShowAutocomplete(newValue));
         }
     }, { isActive });
@@ -199,7 +195,6 @@ const InputPane = ({ commandHandler, exitOnEmptyInput = false, onSubmit, onComma
                     setShowAutocomplete(false);
                     setSelectedIndex(0);
                     setCursorPosition(selectedCommand.length);
-                    setAutoCompleteTriggered(true);
                 }
             }, visible: showAutocomplete })));
 };

package/dist/src/config.d.ts

@@ -106,6 +106,8 @@ interface PlannerAgentConfig extends AgentConfig {
     styles?: string[];
     stylesDir?: string;
     docsWeight?: number;
+    minTests?: number;
+    maxTests?: number;
 }
 interface ScoutAgentConfig extends AgentConfig {
     dirs?: string[];
@@ -219,7 +221,7 @@ interface ExplorbotConfig {
         knowledge: string;
         experience: string;
         output: string;
-        spec?: string;
+        spec?: string | string[];
     };
     experience?: {
         maxReadLines?: number;
@@ -282,7 +284,6 @@ export declare class ConfigParser {
     loadConfigModule(configPath: string): Promise<any>;
     resolveConfig(config: ExplorbotConfig): ExplorbotConfig;
     validateConfig(config: ExplorbotConfig): void;
-    getNestedValue(obj: any, path: string): any;
     mergeWithDefaults(config: Partial<ExplorbotConfig>): ExplorbotConfig;
     ensureDirectory(path: string): void;
 }

package/dist/src/config.js

@@ -29,15 +29,6 @@ export const PROVIDERS = {
 export const MODEL_ROLES = ['model', 'visionModel', 'agenticModel'];
 let cachedOutputRoot = null;
 let runOutputDir = null;
-const config = {
-    playwright: {
-        browser: 'chromium',
-        url: 'http://localhost:3000',
-    },
-    ai: {
-        model: null,
-    },
-};
 export { EXPLORBOT_CONFIG_PATHS };
 export const EXPLORBOT_ENV_VARS = [
     { name: 'EXPLORBOT_AI_PROVIDER', required: true, description: 'Provider name; fills every model role from its recommended models. Turns on config-free mode' },
@@ -455,9 +446,6 @@ export class ConfigParser {
             throw new Error(`Invalid URL in configuration: ${url}`);
         }
     }
-    getNestedValue(obj, path) {
-        return path.split('.').reduce((current, key) => current?.[key], obj);
-    }
     mergeWithDefaults(config) {
         const defaults = {
             playwright: {
@@ -560,6 +548,8 @@ export function configuredModels(ai) {
         models.agenticModel = describe(ai.agenticModel);
     if (ai.visionModel)
         models.visionModel = describe(ai.visionModel);
+    if (ai.decisionModel)
+        models.decisionModel = { name: ai.decisionModel.model, provider: ai.decisionModel.provider };
     for (const [agent, agentConfig] of Object.entries(ai.agents || {})) {
         if (agentConfig?.model)
             models[agent] = describe(agentConfig.model);

package/dist/src/explorbot.d.ts

@@ -41,7 +41,7 @@ export interface ExplorBotOptions {
     optionalAi?: boolean;
     reporter?: ReporterConfig;
     attachedBrowser?: Browser;
-    applicationSpec?: string;
+    applicationSpec?: string | string[];
 }
 export type UserResolveFunction = (error?: Error, showWelcome?: boolean) => Promise<string | null>;
 export declare class ExplorBot {
@@ -113,8 +113,9 @@ export declare class ExplorBot {
         fresh?: boolean;
         style?: string;
         extend?: Plan;
-        completedPlans?: Plan[];
         noSave?: boolean;
+        minTests?: number;
+        maxTests?: number;
     }): Promise<Plan>;
     getPlansDir(): string;
     savePlan(filename?: string): string | null;

package/dist/src/explorbot.js

@@ -126,7 +126,14 @@ export class ExplorBot {
         await this.visit(this.options.from || '/');
     }
     async visit(url) {
-        await this.agentNavigator().visit(this.configParser.resolveTargetPath(url));
+        const target = this.configParser.resolveTargetPath(url);
+        await this.agentNavigator()
+            .visit(target)
+            .catch(async (err) => {
+            if (await this.agentCaptain().resolveBlocker(err, () => this.agentNavigator().isOn(target)))
+                return;
+            throw err;
+        });
     }
     async openTab() {
         await this.explorer.openTab();
@@ -226,7 +233,7 @@ export class ExplorBot {
             if (this.isHistorianEnabled())
                 this.agents.tester.setHistorian(this.agentHistorian());
             this.agents.tester.setPilot(this.agentPilot());
-            this.agents.tester.setCaptain(this.agentCaptain());
+            this.agents.tester.setSupervisor((input, test) => this.agentCaptain().processSupervisorInterrupt(input, test));
             const fisherman = this.agentFisherman();
             if (fisherman)
                 this.agentPilot().setFisherman(fisherman);
@@ -320,9 +327,14 @@ export class ExplorBot {
     }
     agentScout() {
         const scoutConfig = this.config.ai?.agents?.scout;
-        if (scoutConfig?.enabled !== true)
-            return null;
         const dirs = this.scoutCorpusDirs();
+        const hasSpec = dirs.length > 0;
+        const explicitlyDisabled = scoutConfig?.enabled === false;
+        const explicitlyEnabled = scoutConfig?.enabled === true;
+        if (explicitlyDisabled)
+            return null;
+        if (!explicitlyEnabled && !hasSpec)
+            return null;
         if (dirs.length === 0) {
             tag('warning').log('Scout enabled but no documentation found — set --spec or ai.agents.scout.dirs');
             return null;
@@ -331,12 +343,11 @@ export class ExplorBot {
     }
     scoutCorpusDirs() {
         const dirs = [];
-        const specPath = this.options.applicationSpec || this.config.dirs?.spec;
-        if (specPath) {
+        const specPaths = normalizeSpecPaths(this.options.applicationSpec || this.config.dirs?.spec);
+        for (const specPath of specPaths) {
             const bundle = resolveSpecBundlePath(specPath);
-            const pagesDir = bundle && path.join(bundle, 'pages');
-            if (pagesDir && existsSync(pagesDir))
-                dirs.push(pagesDir);
+            if (bundle && existsSync(bundle))
+                dirs.push(bundle);
         }
         for (const dir of this.config.ai?.agents?.scout?.dirs || []) {
             const resolved = this.configParser.resolveProjectDir(dir);
@@ -372,14 +383,20 @@ export class ExplorBot {
         }
         const planner = this.agentPlanner();
         planner.freshStart = !!opts.fresh;
+        if (opts.minTests !== undefined || opts.maxTests !== undefined) {
+            planner.setTestCount({ minTests: opts.minTests, maxTests: opts.maxTests });
+        }
         if (this.currentPlan) {
             planner.setPlan(this.currentPlan);
         }
         this.lastPlanError = null;
+        const before = new Set(this.currentPlan?.tests ?? []);
         try {
-            this.setCurrentPlan(await planner.plan(feature, opts.style, opts.extend, opts.completedPlans));
+            this.setCurrentPlan(await planner.plan(feature, opts.style, opts.extend));
         }
         catch (err) {
+            if (await this.agentCaptain().resolveBlocker(err, () => !!this.currentPlan?.tests.some((t) => !before.has(t))))
+                return this.currentPlan;
             this.lastPlanError = err instanceof Error ? err : new Error(String(err));
             tag('warning').log(`Planning failed: ${this.lastPlanError.message}`);
             if (!this.currentPlan)
@@ -504,3 +521,8 @@ export class ExplorBot {
         }
     }
 }
+function normalizeSpecPaths(spec) {
+    if (!spec)
+        return [];
+    return Array.isArray(spec) ? spec : [spec];
+}

package/dist/src/explorer.js

@@ -148,7 +148,6 @@ class Explorer {
         if (!(await this.recoverOrRestart())) {
             return { ok: false, action: 'stop', message: 'Browser page could not be recovered' };
         }
-        this.watchActiveTestPage();
         return { ok: true, action: 'continue', recovered: true, message: 'Browser page was recovered' };
     }
     async beginTest(test) {
@@ -157,7 +156,7 @@ class Explorer {
         }
         this._activeTest = test;
         test.start();
-        await this.reporter.reportTestStart(test);
+        await this.reporter.reportTestStart();
         await this.closeOtherTabs();
         this.stateManager.otherTabs = [];
         const codeceptjsTest = toCodeceptjsTest(test);
@@ -340,7 +339,7 @@ class Explorer {
     }
     async runWithRecovery(label, operation) {
         if (!this.page && !(await this.recoverOrRestart())) {
-            throw new Error(`Browser page is unavailable before ${label}`);
+            throw new BrowserRecoveryError(label, new Error('Browser page is unavailable'), false);
         }
         try {
             return await operation();
@@ -432,7 +431,6 @@ class Explorer {
         if (!(await this.recoverOrRestart())) {
             return { ok: false, action: 'stop', recovered: false, message: `Browser could not be recovered after fatal error: ${message}` };
         }
-        this.watchActiveTestPage();
         return {
             ok: true,
             action: 'continue',
@@ -446,9 +444,10 @@ class Explorer {
         };
     }
     async recoverOrRestart() {
-        if (await this.recoverPage())
-            return true;
-        return this.restartBrowser();
+        if (!(await this.recoverPage()) && !(await this.restartBrowser()))
+            return false;
+        this.watchActiveTestPage();
+        return true;
     }
     async recoverPage() {
         try {

package/dist/src/knowledge-tracker.d.ts

@@ -5,7 +5,7 @@ export declare class KnowledgeTracker {
     knowledgeFiles: Knowledge[];
     sessionKnowledge: Knowledge[];
     isLoaded: boolean;
-    applicationSpec?: ApplicationSpec;
+    applicationSpecs: ApplicationSpec[];
     static appendSessionKnowledge(text: string): void;
     static resetSessionKnowledge(): void;
     constructor(options?: KnowledgeTrackerOptions);
@@ -48,6 +48,6 @@ export interface Knowledge {
     [key: string]: any;
 }
 export interface KnowledgeTrackerOptions {
-    applicationSpec?: string;
+    applicationSpec?: string | string[];
     knowledgeDir?: string;
 }

package/dist/src/knowledge-tracker.js

@@ -19,7 +19,7 @@ export class KnowledgeTracker {
     knowledgeFiles = [];
     sessionKnowledge = [];
     isLoaded = false;
-    applicationSpec;
+    applicationSpecs = [];
     static appendSessionKnowledge(text) {
         sessionEntries.push(text);
     }
@@ -39,9 +39,15 @@ export class KnowledgeTracker {
         if (!existsSync(this.knowledgeDir)) {
             mkdirSync(this.knowledgeDir, { recursive: true });
         }
-        if (specPath) {
-            this.applicationSpec = new ApplicationSpec(specPath);
-            tag('info').log(`Loaded application spec with ${this.applicationSpec.pageCount} documented pages`);
+        for (const p of normalizeSpecPaths(specPath)) {
+            const spec = new ApplicationSpec(p);
+            this.applicationSpecs.push(spec);
+            if (spec.pageCount > 0) {
+                tag('info').log(`Loaded application spec with ${spec.pageCount} documented pages`);
+            }
+            else if (spec.markdownFileCount > 0) {
+                tag('info').log(`Loaded spec corpus with ${spec.markdownFileCount} markdown files`);
+            }
         }
         this.sessionKnowledge = sessionEntries.map((entry, index) => {
             const parsed = matter(entry);
@@ -77,10 +83,11 @@ export class KnowledgeTracker {
         return [this.renderRelevantKnowledge(state), this.renderApplicationSpec(state)].filter(Boolean).join('\n\n');
     }
     renderApplicationSpec(state) {
-        return this.applicationSpec?.renderFor(state) || '';
+        const parts = this.applicationSpecs.map((spec) => spec.renderFor(state)).filter(Boolean);
+        return parts.join('\n\n');
     }
     applicationSpecUrls(state) {
-        return this.applicationSpec?.matchedUrls(state) || [];
+        return this.applicationSpecs.flatMap((spec) => spec.matchedUrls(state));
     }
     addKnowledge(urlPattern, description, opts) {
         const configParser = ConfigParser.getInstance();
@@ -236,3 +243,8 @@ export class KnowledgeTracker {
     `;
     }
 }
+function normalizeSpecPaths(spec) {
+    if (!spec)
+        return [];
+    return Array.isArray(spec) ? spec : [spec];
+}

package/dist/src/playwright-recorder.d.ts

@@ -8,7 +8,6 @@ export interface VerificationStep {
     args: any[];
 }
 export declare class PlaywrightRecorder {
-    context: any;
     tracing: any;
     active: boolean;
     nextGroupId: number;

package/dist/src/playwright-recorder.js

@@ -23,7 +23,6 @@ function getAsLocator() {
     return cachedAsLocator;
 }
 export class PlaywrightRecorder {
-    context = null;
     tracing = null;
     active = false;
     nextGroupId = 0;
@@ -52,7 +51,6 @@ export class PlaywrightRecorder {
             debugLog('start: no tracing on browserContext, recorder inactive');
             return;
         }
-        this.context = browserContext;
         this.tracing = browserContext.tracing;
         try {
             await this.tracing.start({});

package/dist/src/reporter.d.ts

@@ -22,7 +22,7 @@ export declare class Reporter {
     configureMarkdownPipe(): void;
     configureRunGroup(runGroup: string | null | undefined): void;
     startRun(): Promise<void>;
-    reportTestStart(test: Test): Promise<void>;
+    reportTestStart(): Promise<void>;
     combineStepsAndNotes(test: Test, lastScreenshotFile?: string): Step[];
     buildVerificationStep(test: Test, lastScreenshotFile?: string): Step | undefined;
     reportTest(test: Test, meta?: ReporterMeta): Promise<void>;

package/dist/src/reporter.js

@@ -106,13 +106,13 @@ export class Reporter {
         process.env.TESTOMATIO_STACK_PASSED = 'true';
         process.env.TESTOMATIO_STEPS_PASSED = 'true';
     }
-    async reportTestStart(test) {
+    async reportTestStart() {
         await this.startRun();
     }
     combineStepsAndNotes(test, lastScreenshotFile) {
         const noteEntries = Object.entries(test.notes)
             .filter(([, note]) => !note.observation)
-            .map(([timestampKey, note]) => ({
+            .map(([, note]) => ({
             startTime: note.startTime,
             endTime: note.endTime,
             message: note.message,
@@ -122,7 +122,7 @@ export class Reporter {
         }))
             .sort((a, b) => a.startTime - b.startTime);
         const stepEntries = Object.entries(test.steps)
-            .map(([timestampKey, stepData]) => ({
+            .map(([, stepData]) => ({
             noteStartTime: stepData.noteStartTime,
             text: stepData.text,
             duration: stepData.duration,

package/dist/src/test-plan.js

@@ -461,7 +461,7 @@ export class Plan {
         if (!plansDir)
             dirs.push(...listSitePlanDirs());
         for (const dir of dirs) {
-            const filePath = names.map((name) => path.resolve(dir, name)).find(existsSync);
+            const filePath = names.map((name) => path.resolve(dir, name)).find((candidate) => existsSync(candidate) && statSync(candidate).isFile());
             if (filePath)
                 return filePath;
         }

package/dist/src/utils/error-page.d.ts

@@ -11,3 +11,20 @@ export declare class ErrorPageError extends Error {
     readonly httpStatus?: number;
     constructor(url: string, title?: string, httpStatus?: number);
 }
+export declare class BlockedError extends Error {
+    readonly url: string;
+    readonly blocker: string;
+    readonly request: string;
+    constructor(message: string, url: string, blocker: string, request: string);
+}
+export declare class PlanningBlockedError extends BlockedError {
+    readonly feature?: string;
+    readonly style?: string;
+    constructor(url: string, prerequisite: string, feature?: string, style?: string);
+}
+export declare class NavigationBlockedError extends BlockedError {
+    constructor(url: string, currentUrl: string, reason: string, tried: string[]);
+}
+export declare class TestStartBlockedError extends BlockedError {
+    constructor(scenario: string, url: string, currentUrl: string);
+}

package/dist/src/utils/error-page.js

@@ -1,5 +1,6 @@
+import dedent from 'dedent';
 import { ActionResult } from '../action-result.js';
-import { isBodyEmpty } from './html.js';
+import { isBodyEmpty, sanitizeHtmlString } from './html.js';
 import { extractStatePath } from './url-matcher.js';
 const HTTP_ERRORS = ['400 Bad Request', '401 Unauthorized', '403 Forbidden', '404 Not Found', '405 Method Not Allowed', '408 Request Timeout', '500 Internal Server Error', '502 Bad Gateway', '503 Service Unavailable', '504 Gateway Timeout'];
 const SMALL_PAGE_THRESHOLD = 500;
@@ -27,7 +28,7 @@ export function detectPageCondition(actionResult) {
     }
     if (!actionResult.html || isBodyEmpty(actionResult.html))
         return 'loading';
-    const bodyMatch = actionResult.html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+    const bodyMatch = sanitizeHtmlString(actionResult.html).match(/<body[^>]*>([\s\S]*?)<\/body>/i);
     if (bodyMatch && bodyMatch[1].trim().length < SMALL_PAGE_THRESHOLD)
         return 'loading';
     return 'ok';
@@ -62,3 +63,53 @@ export class ErrorPageError extends Error {
         this.name = 'ErrorPageError';
     }
 }
+export class BlockedError extends Error {
+    url;
+    blocker;
+    request;
+    constructor(message, url, blocker, request) {
+        super(message);
+        this.url = url;
+        this.blocker = blocker;
+        this.request = request;
+        this.name = 'BlockedError';
+    }
+}
+export class PlanningBlockedError extends BlockedError {
+    feature;
+    style;
+    constructor(url, prerequisite, feature, style) {
+        let focus = '';
+        if (feature)
+            focus = ` focused on "${feature}"`;
+        let styleNote = '';
+        if (style)
+            styleNote = ` in ${style} style`;
+        super(`Planner could not plan ${url}: ${prerequisite}`, url, prerequisite, dedent `
+        Planner was asked to plan tests for ${url}${focus}${styleNote} but stopped: ${prerequisite}.
+        Look at the current page to find out what blocks planning, resolve it, then call plan() to re-plan this page. If it cannot be resolved, finish without planning.
+      `);
+        this.feature = feature;
+        this.style = style;
+        this.name = 'PlanningBlockedError';
+    }
+}
+export class NavigationBlockedError extends BlockedError {
+    constructor(url, currentUrl, reason, tried) {
+        const lines = [`Navigator was asked to open ${url} but stopped on ${currentUrl}: ${reason}.`];
+        if (tried.length)
+            lines.push(`Already tried: ${tried.join('; ')}.`);
+        lines.push(`Look at the current page to find out what keeps it from ${url}, resolve it, then open ${url}. If it cannot be resolved, finish without opening it.`);
+        super(`Navigation to ${url} failed: ${reason}`, url, reason, lines.join('\n'));
+        this.name = 'NavigationBlockedError';
+    }
+}
+export class TestStartBlockedError extends BlockedError {
+    constructor(scenario, url, currentUrl) {
+        super(`Test "${scenario}" could not start: ${currentUrl} is not the page it starts on`, url, 'not the start page of this test', dedent `
+        Tester was asked to start the test "${scenario}" at ${url}, but the page open at ${currentUrl} is not where this test can start.
+        Look at the current page to find out what keeps the test from starting, resolve it, then open ${url}. When you finish, the test runs again from ${url}. If it cannot be resolved, finish and the test is skipped.
+      `);
+        this.name = 'TestStartBlockedError';
+    }
+}

package/dist/src/utils/html-diff.d.ts

@@ -1,4 +1,3 @@
-import type { HtmlConfig } from '../config.js';
 export interface HtmlDiffPart {
     container: string;
     subtree: string;
@@ -21,7 +20,7 @@ export declare function computeHtmlFingerprint(html: string): string[];
 /**
  * Compares two HTML documents and returns differences along with a diff subtree.
  */
-export declare function htmlDiff(originalHtml: string, modifiedHtml: string, htmlConfig?: HtmlConfig): Promise<HtmlDiffResult>;
+export declare function htmlDiff(originalHtml: string, modifiedHtml: string): Promise<HtmlDiffResult>;
 /**
  * Text the app announced across a navigation. Only live regions: everything else on a new page is its content, not a message.
  */

package/dist/src/utils/html-diff.js

@@ -138,9 +138,9 @@ export function computeHtmlFingerprint(html) {
 /**
  * Compares two HTML documents and returns differences along with a diff subtree.
  */
-export async function htmlDiff(originalHtml, modifiedHtml, htmlConfig) {
-    const originalDocument = parseDocument(originalHtml, htmlConfig);
-    const modifiedDocument = parseDocument(modifiedHtml, htmlConfig);
+export async function htmlDiff(originalHtml, modifiedHtml) {
+    const originalDocument = parseDocument(originalHtml);
+    const modifiedDocument = parseDocument(modifiedHtml);
     const originalRoot = getRootNodeForFlatten(originalDocument);
     const modifiedRoot = getRootNodeForFlatten(modifiedDocument);
     const originalLines = flattenHtml(originalRoot);
@@ -229,7 +229,7 @@ function isLiveRegion(element) {
  * Parse HTML into a document, wrapping fragments with html/body for consistency.
  * Uses custom sanitization that removes iframes for diff purposes.
  */
-function parseDocument(html, htmlConfig) {
+function parseDocument(html) {
     const document = parse(html);
     const documentTitle = getDocumentTitle(document);
     sanitizeDocumentTreeForDiff(document);
@@ -336,34 +336,6 @@ const attributesDiffer = (current, previous) => {
     }
     return false;
 };
-const getDirectTextValues = (element) => {
-    if (!element.childNodes || element.childNodes.length === 0) {
-        return [];
-    }
-    const values = [];
-    for (const child of element.childNodes) {
-        if (child.nodeName === '#text') {
-            const value = child.value.trim();
-            if (value.length > 0) {
-                values.push(value);
-            }
-        }
-    }
-    return values;
-};
-const directTextDiffer = (current, previous) => {
-    const currentText = getDirectTextValues(current);
-    const previousText = getDirectTextValues(previous);
-    if (currentText.length !== previousText.length) {
-        return true;
-    }
-    for (let i = 0; i < currentText.length; i++) {
-        if (currentText[i] !== previousText[i]) {
-            return true;
-        }
-    }
-    return false;
-};
 function filterContainerClasses(classes) {
     return classes
         .filter((cls) => !/\d/.test(cls))
@@ -654,18 +626,6 @@ function findHtmlElement(document) {
     }
     return null;
 }
-function findHeadElement(document) {
-    const html = findHtmlElement(document);
-    if (!html || !html.childNodes) {
-        return null;
-    }
-    for (const node of html.childNodes) {
-        if ('tagName' in node && node.tagName && node.tagName.toLowerCase() === 'head') {
-            return node;
-        }
-    }
-    return null;
-}
 function findBodyElement(document) {
     const html = findHtmlElement(document);
     if (!html || !html.childNodes) {

package/dist/src/utils/logger.js

@@ -5,6 +5,7 @@ import chalk from 'chalk';
 import debug from 'debug';
 import dedent from 'dedent';
 import stripAnsi from 'strip-ansi';
+import wrapAnsi from 'wrap-ansi';
 import { ConfigParser } from '../config.js';
 import { Observability } from "../observability.js";
 import { RecentStepFilter } from "./log-filters.js";
@@ -54,6 +55,10 @@ class ConsoleDestination {
     forceEnabled = false;
     quiet = false;
     recentSteps = new RecentStepFilter();
+    width;
+    constructor() {
+        this.width = process.stdout.columns || 80;
+    }
     isEnabled() {
         if (this.quiet)
             return false;
@@ -87,8 +92,7 @@ class ConsoleDestination {
         if (entry.type === 'multiline' || entry.type === 'details') {
             const cleaned = stripAnsi(dedent(entry.content));
             const parsed = parseMarkdownToTerminal(cleaned);
-            content = parsed;
-            content = `${chalk.gray(content)}\n`;
+            content = `${chalk.dim('\n ┌'.padEnd(this.width, '─'))}\n${this.prefixLines(parsed, ' │ ', chalk.dim, false)}\n`;
         }
         else if (entry.type === 'success') {
             content = `${chalk.green(content)}\n`;
@@ -100,16 +104,33 @@ class ConsoleDestination {
             content = chalk.yellow(content);
         }
         else if (entry.type === 'step') {
-            content = chalk.gray(`   ${content}`);
+            content = this.prefixLines(content, '   ', chalk.gray);
         }
         else if (entry.type === 'operation') {
-            content = chalk.gray(`   · ${content}`);
+            content = this.prefixLines(content, '   · ', chalk.gray);
         }
         else if (entry.type === 'substep') {
-            content = chalk.gray(`   > ${content}`);
+            content = this.prefixLines(content, '   > ', chalk.gray);
         }
         console.log(content);
     }
+    prefixLines(content, prefix, style, strip = true) {
+        const prefixWidth = stripAnsi(prefix).length;
+        const available = Math.max(20, this.width - prefixWidth);
+        const lines = content
+            .split('\n')
+            .filter((line) => stripAnsi(line).trim() !== '')
+            .flatMap((line) => {
+            const text = strip ? stripAnsi(line) : line;
+            const wrapped = wrapAnsi(text, available, { hard: true });
+            return wrapped.split('\n').map((part) => style(`${prefix}${part}`));
+        });
+        if (lines.length > 10) {
+            const remaining = lines.length - 10;
+            return [...lines.slice(0, 10), chalk.gray(` │ --- +${remaining} lines ---`)].join('\n');
+        }
+        return lines.join('\n');
+    }
 }
 class DebugDestination {
     verboseMode = false;
@@ -138,13 +159,9 @@ class DebugDestination {
 class FileDestination {
     initialized = false;
     logFilePath = null;
-    verboseMode = true;
     isEnabled() {
         return true;
     }
-    setVerboseMode(enabled) {
-        this.verboseMode = enabled;
-    }
     write(entry) {
         if (entry.type === 'html')
             return;
@@ -358,7 +375,7 @@ class Logger {
     truncateTagContent(content, tagName) {
         const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
         const tagRegex = new RegExp(`<${escapedTag}>([\\s\\S]*?)<\\/${escapedTag}>`, 'g');
-        return content.replace(tagRegex, (match, innerContent) => {
+        return content.replace(tagRegex, (_, innerContent) => {
             const trimmed = innerContent.trim();
             const totalLength = trimmed.length;
             if (totalLength <= 100) {