@midscene/test 1.16.0 → 1.16.2

package/dist/lib/test-cli.js

@@ -29,7 +29,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         module.exports = {
-            rE: "1.16.0"
+            rE: "1.16.2"
         };
     }
 };
@@ -93,6 +93,7 @@ var __webpack_exports__ = {};
     var external_node_fs_ = __webpack_require__("node:fs");
     var external_node_path_ = __webpack_require__("node:path");
     const test_runner_namespaceObject = require("@midscene/core/internal/test-runner");
+    const logger_namespaceObject = require("@midscene/shared/logger");
     var package_0 = __webpack_require__("./package.json");
     const external_node_util_namespaceObject = require("node:util");
     const formatCliError = (error)=>'string' == typeof error ? error : (0, external_node_util_namespaceObject.inspect)(error, {
@@ -100,6 +101,1021 @@ var __webpack_exports__ = {};
             depth: null,
             customInspect: false
         });
+    function formatConciseError(error) {
+        const seen = new Set();
+        const messages = [];
+        let current = error;
+        while(current instanceof Error && !seen.has(current)){
+            seen.add(current);
+            if ('NODE_EXECUTION_ERROR' === current.code && void 0 !== current.cause) {
+                current = current.cause;
+                continue;
+            }
+            if (current.message && !messages.includes(current.message)) messages.push(current.message);
+            if (current instanceof AggregateError) {
+                for (const nested of current.errors)if (!(nested === current || seen.has(nested))) {
+                    seen.add(nested);
+                    messages.push(nested instanceof Error ? nested.message : String(nested));
+                }
+            }
+            current = current.cause;
+        }
+        if (!messages.length) return current instanceof Error ? current.message : formatCliError(current);
+        return messages.join('\nCaused by: ');
+    }
+    var external_chalk_ = __webpack_require__("chalk");
+    var external_chalk_default = /*#__PURE__*/ __webpack_require__.n(external_chalk_);
+    const external_string_width_namespaceObject = require("string-width");
+    var external_string_width_default = /*#__PURE__*/ __webpack_require__.n(external_string_width_namespaceObject);
+    const external_node_url_namespaceObject = require("node:url");
+    const oneLine = (value)=>(0, external_node_util_namespaceObject.stripVTControlCharacters)(value).replace(/\s+/g, ' ').trim();
+    const shorten = (value, length)=>{
+        const text = oneLine(value);
+        return text.length <= length ? text : `${text.slice(0, length - 1)}…`;
+    };
+    function firstBusinessFrame(error, projectRoot) {
+        const seen = new Set();
+        const frames = [];
+        const visit = (value, depth = 0)=>{
+            if (!value || 'object' != typeof value || seen.has(value) || depth > 12) return;
+            seen.add(value);
+            const detail = value;
+            visit(detail.cause, depth + 1);
+            if (Array.isArray(detail.errors)) for (const child of detail.errors.slice(0, 10))visit(child, depth + 1);
+            if ('string' != typeof detail.stack) return;
+            for (const line of detail.stack.split('\n')){
+                if (!line.trim().startsWith('at ')) continue;
+                let location = line.trim().slice(3).replace(/^async /, '');
+                if (location.endsWith(')')) location = location.slice(location.lastIndexOf('(') + 1, -1);
+                const match = location.match(/^(.*):(\d+):(\d+)$/);
+                if (!match) continue;
+                let file = match[1];
+                if (file.startsWith('file://')) try {
+                    file = (0, external_node_url_namespaceObject.fileURLToPath)(file);
+                } catch  {
+                    continue;
+                }
+                const normalized = file.replace(/\\/g, '/');
+                if (!(normalized.startsWith('node:') || normalized.includes('/node_modules/') || /(?:^|\/)packages\/(?:core|test|shared|web-integration)\/(?:dist|src)\//.test(normalized)) && /\.[cm]?[jt]sx?$/.test(normalized)) frames.push(`${file}:${match[2]}:${match[3]}`);
+            }
+        };
+        visit(error);
+        const chosen = frames[0];
+        if (!chosen || !projectRoot) return chosen;
+        const match = chosen.match(/^(.*):(\d+):(\d+)$/);
+        const file = match[1];
+        const paths = /^[A-Za-z]:[\\/]/.test(file) ? external_node_path_.win32 : {
+            isAbsolute: external_node_path_.isAbsolute,
+            relative: external_node_path_.relative
+        };
+        const display = paths.isAbsolute(file) ? paths.relative(projectRoot, file) : file;
+        return `${display.replace(/\\/g, '/')}:${match[2]}:${match[3]}`;
+    }
+    function formatFailureInput(input) {
+        if (void 0 === input) return [];
+        const value = (0, test_runner_namespaceObject.sanitizeReportValue)(input).value;
+        const render = (value)=>shorten((0, test_runner_namespaceObject.sanitizeReportError)({
+                message: 'string' == typeof value ? value : (0, external_node_util_namespaceObject.inspect)(value, {
+                    colors: false,
+                    depth: 2,
+                    maxArrayLength: 4,
+                    maxStringLength: 180,
+                    breakLength: 1 / 0,
+                    customInspect: false,
+                    getters: false
+                })
+            }).message, 160);
+        if (value && 'object' == typeof value && !Array.isArray(value)) {
+            const entries = Object.entries(value);
+            const rows = entries.slice(0, 4).map(([key, value])=>`${shorten(key, 48)}: ${render(value)}`);
+            if (entries.length > 4) rows.push(`… ${entries.length - 4} more fields (see Summary)`);
+            return rows;
+        }
+        return [
+            render(value)
+        ];
+    }
+    function formatFailureDetails(source, error, context = {}) {
+        const title = context.projectName ? `[${oneLine(context.projectName)}] ${oneLine(context.caseName ?? context.sourcePath ?? context.phase ?? source)}` : oneLine(source);
+        const body = [];
+        const field = (label, value)=>body.push(`  ${label.padEnd(9)}${value}`);
+        const step = context.step;
+        if (step) {
+            const phase = 'steps' === step.phase ? '' : `${step.phase} `;
+            const index = step.stepIndex + 1;
+            const position = void 0 === context.stepCount ? String(index) : `${index}/${Math.max(index, context.stepCount)}`;
+            field('Step', `${phase}${position} · ${oneLine(step.node)}`);
+        } else if (context.phase) field('Phase', oneLine(context.phase));
+        if (context.sourcePath) {
+            const location = step?.meta.sourceLocation;
+            field('Location', `${oneLine(context.sourcePath)}${location ? `:${location.line}` : ''}`);
+        }
+        for (const [label, attempt] of [
+            [
+                'Attempt',
+                context.attempt
+            ],
+            [
+                'File try',
+                context.fileAttempt
+            ]
+        ])if (attempt && (attempt.total > 1 || attempt.index > 0)) field(label, `${attempt.index + 1}/${attempt.total}`);
+        if (body.length) body.push('');
+        const safeMessage = (0, test_runner_namespaceObject.sanitizeReportError)({
+            message: formatConciseError(error)
+        }).message;
+        const lines = (0, external_node_util_namespaceObject.stripVTControlCharacters)(safeMessage).split(/\r?\n/);
+        body.push(`  Error: ${shorten(lines[0], 320)}`, ...lines.slice(1, 6).map((line)=>`         ${shorten(line, 320)}`));
+        if (lines.length > 6) body.push('         … (use --reporter verbose for details)');
+        const input = step ? formatFailureInput(step.input) : [];
+        if (input.length) {
+            body.push('');
+            input.forEach((line, index)=>field(0 === index ? 'Input' : '', line));
+        }
+        const frame = firstBusinessFrame(error, context.projectRoot);
+        if (frame) body.push('', `  at ${oneLine(frame)}`);
+        return {
+            title,
+            body
+        };
+    }
+    var env_ = __webpack_require__("@midscene/shared/env");
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    function configuredModelNames() {
+        const env = env_.globalConfigManager.getAllEnvConfig();
+        const defaultName = env.MIDSCENE_MODEL_NAME;
+        const models = new Map();
+        for (const [intent, name] of [
+            [
+                'default',
+                defaultName
+            ],
+            [
+                'planning',
+                env.MIDSCENE_PLANNING_MODEL_NAME || defaultName
+            ],
+            [
+                'insight',
+                env.MIDSCENE_INSIGHT_MODEL_NAME || defaultName
+            ]
+        ]){
+            if (!name) continue;
+            const intents = models.get(name) ?? [];
+            intents.push(intent);
+            models.set(name, intents);
+        }
+        return [
+            ...models
+        ].map(([name, intents])=>({
+                name,
+                intents
+            }));
+    }
+    class CliModelUsage {
+        add(step) {
+            for (const trace of step.report?.traces ?? [])if (trace.metrics) {
+                this.executions.set(trace.executionId, trace.metrics);
+                this.missing.delete(trace.executionId);
+            } else if (!this.executions.has(trace.executionId)) this.missing.add(trace.executionId);
+        }
+        snapshot() {
+            if (!this.executions.size && !this.missing.size) return;
+            return (0, test_runner_namespaceObject.sumTestRunReportMetrics)([
+                ...this.executions.values()
+            ], this.missing.size ? [
+                'Some execution usage has not been recorded.'
+            ] : []);
+        }
+        constructor(){
+            _define_property(this, "executions", new Map());
+            _define_property(this, "missing", new Set());
+        }
+    }
+    function formatTokenCount(value) {
+        if (value < 1000) return String(Math.round(value));
+        if (value < 1000000) return `${(value / 1000).toFixed(1)}k`;
+        return `${(value / 1000000).toFixed(1)}m`;
+    }
+    function formatModelUsage(metrics) {
+        if (!metrics) return [
+            '—'
+        ];
+        if (!metrics.models?.length) {
+            const name = metrics.modelCallCount || metrics.collection?.status === 'unknown' ? 'unknown' : '—';
+            return [
+                `${name} · ${formatTokenUsage(metrics)}`
+            ];
+        }
+        return metrics.models.map((model)=>{
+            const name = (0, external_node_util_namespaceObject.stripVTControlCharacters)(model.modelName).replace(/\s+/g, ' ').trim() || 'unknown';
+            const usage = formatTokenUsage({
+                ...metrics,
+                modelCallCount: model.callCount,
+                promptTokens: model.promptTokens,
+                cachedInputTokens: model.cachedInputTokens,
+                completionTokens: model.completionTokens,
+                totalTokens: model.totalTokens
+            });
+            return `${name} · ${usage}`;
+        });
+    }
+    function formatTokenUsage(metrics, includeCached = true) {
+        if (!metrics) return '—';
+        const state = (field)=>metrics.collection?.fields?.[field] ?? metrics.collection?.status ?? 'complete';
+        if ('unknown' === state('totalTokens')) return '— (usage unavailable)';
+        if (!metrics.modelCallCount && !metrics.totalTokens && 'complete' === state('totalTokens')) return '0 (no model calls)';
+        const count = (field)=>'unknown' === state(field) ? '—' : `${'partial' === state(field) ? '≥' : ''}${formatTokenCount(metrics[field])}`;
+        return [
+            `${count('totalTokens')} total${'partial' === state('totalTokens') ? ' (partial)' : ''}`,
+            `${count('promptTokens')} input${includeCached && metrics.cachedInputTokens ? ` (${formatTokenCount(metrics.cachedInputTokens)} cached)` : ''}`,
+            `${count('completionTokens')} output`
+        ].join(' · ');
+    }
+    function terminal_progress_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    const graphemes = new Intl.Segmenter(void 0, {
+        granularity: 'grapheme'
+    });
+    const SYNC_START = '\u001b[?2026h';
+    const SYNC_END = '\u001b[?2026l';
+    const truncateTerminalLine = (text, columns)=>{
+        if (columns <= 0) return '';
+        if (external_string_width_default()(text) <= columns) return text;
+        let output = '';
+        let width = 0;
+        for (const { segment } of graphemes.segment((0, external_node_util_namespaceObject.stripVTControlCharacters)(text))){
+            width += external_string_width_default()(segment);
+            if (width > columns - 1) break;
+            output += segment;
+        }
+        return `${output}…`;
+    };
+    class TerminalProgress {
+        erase() {
+            if (!this.lines.length) return '';
+            const columns = Math.max(1, this.io.columns ?? 100);
+            const occupiedRows = this.lines.reduce((sum, line)=>sum + Math.max(1, Math.ceil(external_string_width_default()(line) / columns)), 0);
+            const rows = Math.min(occupiedRows, Math.max(0, (this.io.rows ?? 24) - 1));
+            this.lines = [];
+            return `\r${rows ? `\u001b[${rows}A` : ''}\u001b[0J`;
+        }
+        frame(previousHeight = 0) {
+            const availableRows = Math.max(0, (this.io.rows ?? 24) - 2);
+            const columns = Math.max(0, (this.io.columns ?? 100) - 1);
+            if (!availableRows || !columns) return '';
+            const footer = this.footer.slice(0, availableRows);
+            const budget = availableRows - footer.length;
+            const overflow = this.content.length > budget;
+            const visible = Math.max(0, budget - (overflow ? 1 : 0));
+            const body = this.content.slice(0, visible);
+            if (overflow && budget > 0) body.push(`  … ${this.content.length - visible} more rows`);
+            const lines = [
+                ...body,
+                ...footer
+            ].map((line)=>truncateTerminalLine(line, columns));
+            const blanks = Math.max(0, Math.min(previousHeight, availableRows) - lines.length);
+            this.lines = [
+                ...Array.from({
+                    length: blanks
+                }, ()=>''),
+                ...lines
+            ];
+            return this.lines.length ? `${this.lines.join('\n')}\n` : '';
+        }
+        render(content, footer) {
+            this.update(content, footer);
+            const previousHeight = this.lines.length;
+            const erase = this.erase();
+            this.io.write?.(`${SYNC_START}${erase}${this.frame(previousHeight)}${SYNC_END}`);
+        }
+        update(content, footer) {
+            this.content = content;
+            this.footer = footer;
+        }
+        output(message, write) {
+            this.io.write?.(SYNC_START);
+            try {
+                const erase = this.erase();
+                if (erase) this.io.write?.(erase);
+                write(message.endsWith('\n') ? message : `${message}\n`);
+                const frame = this.frame();
+                if (frame) this.io.write?.(frame);
+            } finally{
+                this.io.write?.(SYNC_END);
+            }
+        }
+        clear() {
+            const erase = this.erase();
+            this.content = [];
+            this.footer = [];
+            if (erase) this.io.write?.(`${SYNC_START}${erase}${SYNC_END}`);
+        }
+        constructor(io){
+            terminal_progress_define_property(this, "io", void 0);
+            terminal_progress_define_property(this, "lines", void 0);
+            terminal_progress_define_property(this, "content", void 0);
+            terminal_progress_define_property(this, "footer", void 0);
+            this.io = io;
+            this.lines = [];
+            this.content = [];
+            this.footer = [];
+        }
+    }
+    const warning_format_oneLine = (text)=>(0, external_node_util_namespaceObject.stripVTControlCharacters)(text).replace(/\s+/g, ' ').trim();
+    function formatWarningScope(scope) {
+        if (!scope) return '';
+        const parts = [
+            `[${warning_format_oneLine(scope.projectName)}]`
+        ];
+        if (scope.sourcePath) parts.push(warning_format_oneLine(scope.sourcePath));
+        if (scope.caseName) parts.push(warning_format_oneLine(scope.caseName));
+        if (scope.phase) {
+            const phase = 'steps' === scope.phase ? 'step' : scope.phase;
+            parts.push(`${phase}${void 0 === scope.stepIndex ? '' : `[${scope.stepIndex + 1}]`}${scope.node ? ` ${warning_format_oneLine(scope.node)}` : ''}`);
+        }
+        return `${parts.join(' › ')} · `;
+    }
+    function errorMessage(error) {
+        const seen = new Set();
+        let current = error;
+        let message = '';
+        let status;
+        while(current && 'object' == typeof current && !seen.has(current)){
+            seen.add(current);
+            const detail = current;
+            if ('string' == typeof detail.message) message = detail.message;
+            if ('number' == typeof detail.status) status = detail.status;
+            current = detail.cause;
+        }
+        const firstLine = warning_format_oneLine((message || String(error)).split(/\r?\n/)[0]);
+        return status && !firstLine.startsWith(String(status)) ? `${status}: ${firstLine}` : firstLine;
+    }
+    function formatWarning(entry) {
+        const details = entry.warning;
+        let message;
+        if (details?.kind === 'model-request-retry') message = `model request retry ${details.attempt + 1}/${details.maxAttempts} in ${details.delayMs / 1000}s (${warning_format_oneLine(details.modelName)}): ${errorMessage(details.error)}`;
+        else {
+            const error = entry.args?.find((arg)=>arg instanceof Error);
+            const prefix = 'string' == typeof entry.args?.[0] ? warning_format_oneLine(entry.args[0].split(/\r?\n/)[0]).replace(/:\s*$/, '') : '';
+            message = error ? `${prefix ? `${prefix}: ` : ''}${errorMessage(error)}` : warning_format_oneLine(entry.message.split(/\r?\n/)[0]);
+            message = message.replace(/^\[midscene:warning\]\s*/, '');
+        }
+        if (message.startsWith('waitForNetworkIdle is skipped for Playwright.')) message = 'Playwright: post-action network-idle wait skipped.';
+        return message.length > 240 ? `${message.slice(0, 239)}…` : message;
+    }
+    function warningKey(entry, message) {
+        const details = entry.warning;
+        if (details?.kind === 'model-request-retry') return `${entry.topic}\n${JSON.stringify(entry.scope)}\n${details.callId}\n${details.attempt}`;
+        const scope = entry.args?.some((arg)=>arg instanceof Error) ? JSON.stringify(entry.scope) : '';
+        return `${entry.topic}\n${scope}\n${message}`;
+    }
+    function terminal_reporter_define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    const terminal_reporter_oneLine = (value)=>(0, external_node_util_namespaceObject.stripVTControlCharacters)(value).replace(/\s+/g, ' ').trim();
+    const formatDuration = (ms)=>{
+        if (ms < 1000) return `${Math.round(ms)}ms`;
+        if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+        return `${Math.floor(ms / 60000)}m ${Math.floor(ms % 60000 / 1000)}s`;
+    };
+    const identity = (project, path, name)=>`[${terminal_reporter_oneLine(project)}] ${terminal_reporter_oneLine(path)}${name ? ` › ${terminal_reporter_oneLine(name)}` : ''}`;
+    const projectPhaseLabel = (phase)=>'setup' === phase ? 'setting up' : 'cleaning up';
+    const fileStatus = (status, cases)=>{
+        if ('failed' === status || cases.some((item)=>'failed' === item.status)) return 'failed';
+        if (cases.length && cases.every((item)=>'not-run' === item.status)) return 'not-run';
+        if (cases.some((item)=>'not-run' === item.status)) return 'failed';
+        return status ?? (cases.length ? 'success' : 'not-run');
+    };
+    class TerminalReporter {
+        get interactive() {
+            return !!this.io.isTTY && !!this.io.write && 'default' === this.mode;
+        }
+        log(message) {
+            if (this.interactive) this.output(`${message}\n`, (text)=>this.io.write(text));
+            else this.io.log(message);
+            this.lastOutput = Date.now();
+        }
+        output(message, write) {
+            this.renderProgress(false);
+            this.progressView.output(message, write);
+            this.lastOutput = Date.now();
+        }
+        progress(message) {
+            if ('verbose' === this.mode) this.log(message);
+        }
+        console(entry) {
+            if ('report' === entry.type) {
+                if ('verbose' === this.mode) this.log(entry.message);
+                return;
+            }
+            const scope = formatWarningScope(entry.scope);
+            if ('verbose' === this.mode) {
+                const kind = entry.warning?.kind === 'model-request-retry' ? 'model request retry · ' : entry.warning?.kind === 'model-request-detail' ? 'model request error · ' : '';
+                this.log(`WARN ${scope}${kind}${entry.message}`);
+                return;
+            }
+            if (entry.warning?.kind === 'model-request-detail') return;
+            const message = formatWarning(entry);
+            const key = warningKey(entry, message);
+            if (this.warnings.has(key)) return;
+            this.warnings.set(key, {
+                scope,
+                message
+            });
+            if (this.interactive) {
+                let attached = false;
+                if (entry.warning?.kind === 'model-request-retry' && entry.scope) {
+                    const owner = entry.scope;
+                    for (const [id, task] of this.active)if (task.file.projectName === owner.projectName && (!owner.sourcePath || task.file.sourcePath === owner.sourcePath) && (!owner.caseId || id === owner.caseId) && (!owner.runId || task.runId === owner.runId) && (!owner.phase || task.phase === owner.phase) && (void 0 === owner.stepIndex || task.stepIndex === owner.stepIndex)) {
+                        task.warning = message;
+                        attached = true;
+                    }
+                }
+                if (!attached) this.latestNotice = message.startsWith('Playwright:') ? 'Playwright: network-idle wait skipped.' : `${scope}${message}`;
+                this.schedule();
+                return;
+            }
+            this.log(`${this.color.yellow('WARN')} ${this.color.dim(scope)}${message}`);
+        }
+        file(projectName, sourcePath, total = 0) {
+            const key = `${projectName}\0${sourcePath}`;
+            let file = this.files.get(key);
+            if (!file) {
+                file = {
+                    projectName,
+                    sourcePath,
+                    total,
+                    outcomes: new Map(),
+                    attemptOutcomes: new Map(),
+                    started: false,
+                    printed: false,
+                    durationMs: 0,
+                    retries: 0,
+                    completionOrder: 0
+                };
+                this.files.set(key, file);
+            }
+            file.total = Math.max(file.total, total);
+            return file;
+        }
+        event(event) {
+            if ('run-start' === event.type) {
+                this.total = event.cases;
+                this.totalFiles = event.documents;
+                this.startedAt = event.startedAt ? Date.parse(event.startedAt) : Date.now();
+                for (const file of event.files ?? [])this.file(file.projectName, file.sourcePath, file.cases);
+                const c = this.color;
+                this.log(`\n ${c.bgGreen.black.bold(' RUN ')} ${c.green(`midscene-test v${package_0.rE}`)} ${c.dim(terminal_reporter_oneLine(event.projectRoot ?? process.cwd()))}`);
+                this.log(` ${c.dim(`${event.projects} projects · ${event.documents} files · ${event.cases} cases`)}`);
+                if (void 0 !== event.maxConcurrentProjects && void 0 !== event.maxConcurrentFiles) this.log(` ${c.dim(`Concurrency ${event.maxConcurrentProjects ?? 'unlimited'} projects · ${event.maxConcurrentFiles ?? 'unlimited'} files (global limits)`)}`);
+                if (event.configPath) this.log(` ${c.dim(`Config ${terminal_reporter_oneLine(event.configPath)}`)}`);
+                for (const model of event.configuredModels ?? [])this.log(` ${c.dim('Models (env)')} ${terminal_reporter_oneLine(model.name)} ${c.dim(`· ${model.intents.map(terminal_reporter_oneLine).join(', ')}`)}`);
+                this.log('');
+                if ('default' === this.mode) {
+                    this.timer = setInterval(()=>this.tick(), this.interactive ? 1000 : 30000);
+                    this.timer.unref();
+                    if (this.interactive) this.removeResizeListener = this.io.onResize?.(()=>this.renderProgress());
+                    this.renderProgress();
+                }
+            } else if ('project-end' === event.type) {
+                this.completeProject(event.project);
+                this.schedule();
+            } else if ('project-phase' === event.type) {
+                if ('running' === event.phase) this.projectPhases.delete(event.projectName);
+                else this.projectPhases.set(event.projectName, {
+                    phase: event.phase,
+                    since: Date.now()
+                });
+                this.schedule();
+            } else if ('document-start' === event.type) {
+                this.file(event.projectName, event.sourcePath, event.cases).started = true;
+                this.schedule();
+            } else if ('document-end' === event.type) {
+                const file = this.file(event.document.projectName, event.document.sourcePath, event.cases.length);
+                file.status = fileStatus(event.document.status, event.cases);
+                file.started = true;
+                file.completionOrder = ++this.completionOrder;
+                file.durationMs = event.durationMs;
+                file.retries = event.document.attemptIndex ?? 0;
+                file.outcomes = new Map(event.cases.map((outcome)=>[
+                        outcome.caseId,
+                        outcome
+                    ]));
+                file.attemptOutcomes.clear();
+                for (const [key, task] of this.active)if (task.file === file) this.active.delete(key);
+                if (!this.interactive) this.printFile(file);
+                this.schedule();
+            } else if ('step-start' === event.type) this.startStep(event.projectName, event.info);
+            else if ('step-end' === event.type) {
+                if (event.result) this.usage.add(event.result);
+                const key = 'case' === event.info.scope ? event.info.case.caseId : event.info.document.documentId;
+                const task = this.active.get(key);
+                if (task) if ('document' === event.info.scope) this.active.delete(key);
+                else {
+                    task.step = void 0;
+                    task.warning = void 0;
+                }
+                this.schedule();
+            } else if ('case-attempt-end' === event.type) this.attempts.set(event.attempt.caseId, {
+                run: event.attempt,
+                max: event.maxAttempts
+            });
+            else if ('case-end' === event.type || 'case-progress' === event.type) {
+                const file = this.file(event.outcome.projectName, event.outcome.sourcePath);
+                if ('case-progress' === event.type) {
+                    file.attemptOutcomes.set(event.outcome.caseId, event.outcome);
+                    file.retries = Math.max(file.retries, event.documentAttemptIndex);
+                } else {
+                    file.attemptOutcomes.delete(event.outcome.caseId);
+                    file.outcomes.set(event.outcome.caseId, event.outcome);
+                    file.retries = Math.max(file.retries, event.documentRetries ?? 0);
+                }
+                this.active.delete(event.outcome.caseId);
+                this.schedule();
+            } else if ('document-retry' === event.type) {
+                const file = this.file(event.document.projectName, event.document.sourcePath);
+                file.outcomes.clear();
+                file.attemptOutcomes.clear();
+                file.status = void 0;
+                file.completionOrder = 0;
+                for (const [key, task] of this.active)if (task.file === file) this.active.delete(key);
+                this.log(this.color.yellow(` ↻ ${identity(file.projectName, file.sourcePath)} · file retry ${(event.document.attemptIndex ?? 0) + 2}/${event.maxAttempts}`));
+                this.schedule();
+            }
+        }
+        startStep(projectName, info) {
+            const position = 'case' === info.scope ? info.case : info.document;
+            const file = this.file(projectName, position.sourcePath);
+            file.started = true;
+            const key = 'case' === info.scope ? info.case.caseId : info.document.documentId;
+            const attempt = 'case' === info.scope ? info.case.attemptIndex : 0;
+            const previous = this.attempts.get(key);
+            if (previous && previous.run.attemptIndex < attempt) {
+                this.attempts.delete(key);
+                if ('default' === this.mode && !this.interactive) this.log(this.color.yellow(` ↻ ${identity(projectName, position.sourcePath, 'case' === info.scope ? info.case.name : void 0)} · case retry · attempt ${attempt + 1}/${previous.max}`));
+            }
+            const existing = this.active.get(key);
+            const now = Date.now();
+            this.active.set(key, {
+                file,
+                name: 'case' === info.scope ? info.case.name : void 0,
+                step: `${'steps' === position.phase ? 'step' : position.phase} ${position.stepIndex + 1}/${info.stepCount} · ${terminal_reporter_oneLine(info.node)}`,
+                since: existing?.attempt === attempt ? existing.since : now,
+                attempt,
+                maxAttempts: previous?.max ?? existing?.maxAttempts,
+                runId: 'case' === info.scope ? info.case.runId : info.document.documentRunId,
+                phase: position.phase,
+                stepIndex: position.stepIndex,
+                caseIndex: 'case' === info.scope ? info.case.caseIndex : void 0
+            });
+            this.schedule();
+        }
+        schedule() {
+            if (!this.interactive || !this.timer || this.scheduled) return;
+            this.scheduled = setTimeout(()=>{
+                this.scheduled = void 0;
+                this.renderProgress();
+            }, 100);
+            this.scheduled.unref();
+        }
+        counts(items, total) {
+            const failed = items.filter((item)=>'failed' === item.status).length;
+            const passed = items.filter((item)=>'success' === item.status).length;
+            const notRun = items.filter((item)=>'not-run' === item.status).length;
+            return this.stateCounts(passed, failed, notRun, total);
+        }
+        stateCounts(passed, failed, notRun, total) {
+            const c = this.color;
+            return [
+                failed ? c.red.bold(`${failed} failed`) : '',
+                c.green.bold(`${passed} passed`),
+                notRun ? c.yellow(`${notRun} not run`) : ''
+            ].filter(Boolean).join(c.dim(' | ')) + c.dim(` (${total})`);
+        }
+        footer(durationMs = Date.now() - this.startedAt, result) {
+            const files = [
+                ...this.files.values()
+            ];
+            const cases = files.flatMap((file)=>[
+                    ...file.outcomes.values()
+                ]);
+            const c = this.color;
+            const metrics = result ? this.finalMetrics : this.usage.snapshot();
+            return [
+                ` ${c.dim('Test Files')} ${this.counts(files, this.totalFiles)}`,
+                ` ${c.dim('     Cases')} ${result ? this.stateCounts(result.summary.passed, result.summary.failed, result.summary.notRun, result.summary.total) : this.counts(cases, this.total)}`,
+                ` ${c.dim('  Start at')} ${new Date(this.startedAt).toLocaleTimeString('en-GB', {
+                    hour12: false
+                })}`,
+                ` ${c.dim('  Duration')} ${formatDuration(durationMs)}`,
+                ...formatModelUsage(metrics).map((model, index)=>` ${c.dim(index ? '          ' : '   Models:')} ${model}`),
+                ...!result || this.warnings.size ? [
+                    ` ${c.dim('  Warnings')} ${this.warnings.size ? c.yellow(String(this.warnings.size)) : c.dim('0')}${!result && this.latestNotice ? c.dim(` · ${this.latestNotice}`) : ''}`
+                ] : []
+            ];
+        }
+        renderProgress(render = true) {
+            if (!this.interactive || !this.timer) return;
+            const projects = new Map();
+            const files = [
+                ...this.files.values()
+            ].filter((file)=>file.started && !file.printed).sort((a, b)=>a.projectName.localeCompare(b.projectName) || a.sourcePath.localeCompare(b.sourcePath));
+            for (const file of files){
+                const group = projects.get(file.projectName) ?? [];
+                group.push(file);
+                projects.set(file.projectName, group);
+            }
+            for (const projectName of this.projectPhases.keys())if (!projects.has(projectName)) projects.set(projectName, []);
+            const footer = this.footer();
+            const budget = Math.max(0, (this.io.rows ?? 24) - 2 - footer.length - 1);
+            let lines = this.liveTree(projects, 'full');
+            if (lines.length > budget) lines = this.liveTree(projects, 'recent');
+            if (lines.length > budget) lines = this.liveTree(projects, 'compact');
+            if (lines.length > budget) lines = this.liveTree(projects, 'active');
+            if (lines.length) lines.push('');
+            if (render) this.progressView.render(lines, footer);
+            else this.progressView.update(lines, footer);
+        }
+        liveTree(projects, mode) {
+            const c = this.color;
+            const lines = [];
+            const groups = [
+                ...projects
+            ];
+            const isActive = ([projectName, files])=>this.projectPhases.has(projectName) || files.some((file)=>!file.status);
+            if ('full' !== mode) groups.sort((a, b)=>Number(isActive(b)) - Number(isActive(a)));
+            for (const [projectName, files] of groups){
+                const phase = this.projectPhases.get(projectName);
+                const running = files.filter((file)=>!file.status);
+                const completed = files.filter((file)=>file.status);
+                const recent = [
+                    ...completed
+                ].sort((a, b)=>b.completionOrder - a.completionOrder).slice(0, 'recent' === mode ? 1 : 0);
+                const visible = 'full' === mode ? files : [
+                    ...running,
+                    ...recent
+                ];
+                const hidden = completed.filter((file)=>!visible.includes(file));
+                const hiddenFailures = hidden.filter((file)=>'failed' === file.status).length;
+                const details = [
+                    phase ? c.yellow(`${projectPhaseLabel(phase.phase)} ${formatDuration(Date.now() - phase.since)}`) : '',
+                    c.yellow(`${running.length} ${1 === running.length ? 'file' : 'files'} running`),
+                    completed.length ? c.dim(`${completed.length} completed`) : '',
+                    'active' === mode && hiddenFailures ? c.red(`${hiddenFailures} failed`) : ''
+                ].filter(Boolean);
+                lines.push(this.liveRow(` ${c.yellow('❯')} ${c.bold(terminal_reporter_oneLine(projectName))}`, c.dim(' · ') + details.join(c.dim(' · '))));
+                for (const [fileIndex, file] of visible.entries()){
+                    const lastFile = fileIndex === visible.length - 1 && (!hidden.length || 'active' === mode);
+                    const stem = lastFile ? '      ' : `   ${c.dim('│')}  `;
+                    const outcomes = [
+                        ...new Map([
+                            ...file.attemptOutcomes,
+                            ...file.outcomes
+                        ]).values()
+                    ].sort((a, b)=>a.caseIndex - b.caseIndex);
+                    const failedCases = outcomes.filter((outcome)=>'failed' === outcome.status).length;
+                    lines.push(this.liveRow(`   ${c.dim(lastFile ? '└─' : '├─')} ${file.status ? `${this.statusSymbol(file.status)} ` : ''}${terminal_reporter_oneLine(file.sourcePath)}`, ` ${c.dim(`${outcomes.length}/${file.total} cases`)}${file.status ? c.dim(` ${formatDuration(file.durationMs)}`) : ''}${'active' === mode && failedCases ? c.red(` · ${failedCases} failed`) : ''}`));
+                    const tasks = [
+                        ...this.active.values()
+                    ].filter((task)=>task.file === file);
+                    const shown = 'full' === mode ? outcomes : 'recent' === mode ? outcomes.slice(-1) : [];
+                    const children = [
+                        ...tasks.map((task)=>({
+                                task
+                            })),
+                        ...shown.map((outcome)=>({
+                                outcome
+                            }))
+                    ];
+                    if ('full' === mode) children.sort((a, b)=>this.liveChildIndex(a) - this.liveChildIndex(b));
+                    const hiddenCases = outcomes.filter((outcome)=>!shown.includes(outcome));
+                    if (hiddenCases.length && 'active' !== mode) {
+                        const failed = hiddenCases.filter((outcome)=>'failed' === outcome.status).length;
+                        children.push({
+                            summary: `… ${hiddenCases.length} completed ${1 === hiddenCases.length ? 'case' : 'cases'}${failed ? ` · ${failed} failed` : ''}`,
+                            failed: failed > 0
+                        });
+                    }
+                    for (const [index, child] of children.entries()){
+                        const last = index === children.length - 1;
+                        const prefix = `${stem}${c.dim(last ? '└─' : '├─')} `;
+                        if ('outcome' in child) {
+                            lines.push(this.liveRow(`${prefix}${this.formatCaseResult(child.outcome, file.retries)}`, ''));
+                            continue;
+                        }
+                        if ('summary' in child) {
+                            lines.push(this.liveRow(`${prefix}${child.failed ? c.red(child.summary) : c.dim(child.summary)}`, ''));
+                            continue;
+                        }
+                        const { task } = child;
+                        const hint = task.name && task.step ? truncateTerminalLine(` · ${task.step}`, Math.floor(Math.max(0, (this.io.columns ?? 100) - 1) / 2)) : '';
+                        const retry = task.attempt ? ` · attempt ${task.attempt + 1}${task.maxAttempts ? `/${task.maxAttempts}` : ''}` : '';
+                        lines.push(this.liveRow(`${prefix}${terminal_reporter_oneLine(task.name ?? task.step ?? 'file lifecycle')}`, `${c.dim(hint)} ${c.yellow(formatDuration(Date.now() - task.since))}${c.yellow(retry)}`));
+                        if (task.warning) lines.push(this.liveRow(`${stem}${last ? '   ' : `${c.dim('│')}  `}${c.dim('└─')} ${c.yellow(`⚠ ${task.warning}`)}`, ''));
+                    }
+                }
+                if (hidden.length && 'active' !== mode) {
+                    const summary = `… ${hidden.length} completed ${1 === hidden.length ? 'file' : 'files'}${hiddenFailures ? ` · ${hiddenFailures} failed` : ''}`;
+                    lines.push(this.liveRow(`   ${c.dim('└─')} ${hiddenFailures ? c.red(summary) : c.dim(summary)}`, ''));
+                }
+            }
+            return lines;
+        }
+        liveChildIndex(child) {
+            if ('outcome' in child) return child.outcome.caseIndex;
+            if ('summary' in child) return Number.MAX_SAFE_INTEGER;
+            return child.task.caseIndex ?? ('beforeAll' === child.task.phase ? -1 : Number.MAX_SAFE_INTEGER);
+        }
+        liveRow(label, suffix) {
+            const columns = Math.max(0, (this.io.columns ?? 100) - 1);
+            const tail = truncateTerminalLine(suffix, columns);
+            return truncateTerminalLine(label, columns - external_string_width_default()(tail)) + tail;
+        }
+        tick() {
+            if (this.interactive) return void this.renderProgress();
+            if ((this.active.size || this.projectPhases.size) && Date.now() - this.lastOutput >= 30000) this.log(`… Still running: ${[
+                ...[
+                    ...this.projectPhases
+                ].map(([projectName, phase])=>`[${terminal_reporter_oneLine(projectName)}] · ${projectPhaseLabel(phase.phase)} (${formatDuration(Date.now() - phase.since)})`),
+                ...[
+                    ...this.active.values()
+                ].map((task)=>`${identity(task.file.projectName, task.file.sourcePath, task.name)} · ${task.step ?? 'between steps'} (${formatDuration(Date.now() - task.since)})`)
+            ].join(' | ')}`);
+        }
+        formatCaseResult(outcome, documentRetries) {
+            const c = this.color;
+            const attempts = outcome.attempts ?? (outcome.run ? [
+                outcome.run
+            ] : []);
+            const retries = Math.max(attempts.length - 1, outcome.run?.attemptIndex ?? 0);
+            const duration = formatDuration(attempts.reduce((sum, attempt)=>sum + attempt.durationMs, 0));
+            const symbol = 'success' === outcome.status ? c.green('✓') : 'failed' === outcome.status ? c.red('×') : c.yellow('–');
+            const detail = 'not-run' === outcome.status ? c.dim(` · ${outcome.notRunReason ?? 'not run'}`) : ` ${c.dim(duration)}${retries ? c.yellow(` · ${'success' === outcome.status ? 'passed after retry' : 'failed after retries'} (${retries + 1} attempts)`) : documentRetries ? c.yellow(` · file retried ${documentRetries}x`) : ''}`;
+            return `${symbol} ${terminal_reporter_oneLine(outcome.name)}${detail}`;
+        }
+        statusSymbol(status) {
+            return 'failed' === status ? this.color.red('×') : 'not-run' === status ? this.color.yellow('–') : this.color.green('✓');
+        }
+        resultFileLines(file, lastFile) {
+            const c = this.color;
+            const stem = lastFile ? '      ' : `   ${c.dim('│')}  `;
+            const cases = [
+                ...file.outcomes.values()
+            ].sort((a, b)=>a.caseIndex - b.caseIndex);
+            const failed = cases.filter((item)=>'failed' === item.status).length;
+            const notRun = cases.filter((item)=>'not-run' === item.status).length;
+            const stats = `(${cases.length} cases${failed ? ` | ${failed} failed` : ''}${notRun ? ` | ${notRun} not run` : ''})`;
+            return [
+                `   ${c.dim(lastFile ? '└─' : '├─')} ${this.statusSymbol(file.status)} ${c.bold(terminal_reporter_oneLine(file.sourcePath))} ${c.dim(stats)} ${c.dim(formatDuration(file.durationMs))}`,
+                ...cases.map((item, caseIndex)=>`${stem}${c.dim(caseIndex === cases.length - 1 ? '└─' : '├─')} ${this.formatCaseResult(item, file.retries)}`)
+            ];
+        }
+        printFile(file) {
+            if (file.printed) return;
+            file.printed = true;
+            this.log([
+                '',
+                ` ${this.color.bold(terminal_reporter_oneLine(file.projectName))}`,
+                ...this.resultFileLines(file, true)
+            ].join('\n'));
+        }
+        printProject(projectName, files, failed) {
+            if (!files.length || files.every((file)=>file.printed)) return;
+            const c = this.color;
+            const status = failed || files.some((file)=>'failed' === file.status) ? 'failed' : files.every((file)=>'not-run' === file.status) ? 'not-run' : files.some((file)=>'not-run' === file.status) ? 'failed' : 'success';
+            const lines = [
+                '',
+                ` ${this.statusSymbol(status)} ${c.bold(terminal_reporter_oneLine(projectName))} ${c.dim(`(${files.length} ${1 === files.length ? 'file' : 'files'})`)}`
+            ];
+            for (const [index, file] of files.entries())if (!file.printed) {
+                file.printed = true;
+                lines.push(...this.resultFileLines(file, index === files.length - 1));
+            }
+            this.log(lines.join('\n'));
+        }
+        failure(source, error, context) {
+            this.failures.push({
+                source,
+                error,
+                context
+            });
+        }
+        completeProject(project) {
+            this.projectPhases.delete(project.name);
+            const projectFiles = new Set();
+            const documents = new Map(project.documents.map((document)=>[
+                    document.documentId,
+                    document
+                ]));
+            const resultSources = new Set([
+                ...project.cases.map((outcome)=>outcome.sourcePath),
+                ...project.documents.map((document)=>document.sourcePath),
+                ...project.collectionErrors.map((error)=>error.sourcePath)
+            ]);
+            for (const plan of project.plans ?? []){
+                const selected = plan.cases.filter((item)=>item.selected).length;
+                if (selected || resultSources.has(plan.sourcePath)) projectFiles.add(this.file(project.name, plan.sourcePath, selected));
+            }
+            for (const outcome of project.cases)this.file(project.name, outcome.sourcePath).outcomes.set(outcome.caseId, outcome);
+            for (const document of documents.values()){
+                const file = this.file(project.name, document.sourcePath);
+                file.status = document.status;
+                file.retries = document.attemptIndex ?? 0;
+                file.durationMs = project.documents.filter((item)=>item.documentId === document.documentId).reduce((sum, item)=>sum + item.durationMs, 0);
+            }
+            for (const error of project.collectionErrors)this.file(project.name, error.sourcePath).status = 'failed';
+            for (const file of this.files.values())if (file.projectName === project.name) {
+                file.attemptOutcomes.clear();
+                const cases = [
+                    ...file.outcomes.values()
+                ];
+                file.status = fileStatus(file.status, cases);
+                projectFiles.add(file);
+            }
+            for (const [key, task] of this.active)if (task.file.projectName === project.name) this.active.delete(key);
+            if (this.interactive) this.printProject(project.name, [
+                ...projectFiles
+            ], 'failed' === project.status);
+            else for (const file of projectFiles)this.printFile(file);
+        }
+        finish(result) {
+            this.dispose();
+            this.finalMetrics = result.metrics ?? this.usage.snapshot();
+            if (result.startedAt) this.startedAt = Date.parse(result.startedAt);
+            for (const project of result.projects)this.completeProject(project);
+            this.total = result.summary.total;
+            this.totalFiles = this.files.size;
+        }
+        sectionHeading(label, kind) {
+            const c = this.color;
+            const width = Math.max(0, (this.io.columns ?? 80) - 2);
+            const title = truncateTerminalLine(` ${label} `, width);
+            const padding = Math.max(0, width - external_string_width_default()(title));
+            const left = Math.floor(padding / 2);
+            const line = 'warning' === kind ? c.yellow : c.red;
+            const badge = 'warning' === kind ? c.bgYellow.black.bold : c.bgRed.white.bold;
+            this.log(`\n ${line('─'.repeat(left))}${badge(title)}${line('─'.repeat(padding - left))}\n`);
+        }
+        summary(result) {
+            const c = this.color;
+            if (this.interactive && this.warnings.size) {
+                this.sectionHeading(`Warnings ${this.warnings.size}`, 'warning');
+                for (const warning of [
+                    ...this.warnings.values()
+                ].slice(0, 5))this.log(` ${c.yellow('WARN')} ${c.dim(warning.scope)}${warning.message}`);
+                if (this.warnings.size > 5) this.log(c.dim(` … ${this.warnings.size - 5} more warnings; see debug logs or --reporter verbose.`));
+            }
+            if (this.failures.length) {
+                this.sectionHeading(`Failures ${this.failures.length}`, 'failure');
+                for (const failure of this.failures){
+                    if ('default' === this.mode) {
+                        const detail = formatFailureDetails(failure.source, failure.error, failure.context);
+                        const body = detail.body.map((line)=>{
+                            if (line.startsWith('  Error:')) return c.red(line);
+                            if (line.startsWith('  at ')) return c.dim(line);
+                            return line.replace(/^ {2}(?:Step|Location|Attempt|File try|Phase|Input)\s+/, (label)=>c.dim(label));
+                        }).join('\n');
+                        const block = `${c.bgRed.white.bold(' FAIL ')} ${c.bold(detail.title)}\n${body}\n`;
+                        if (this.interactive) this.log(block);
+                        else this.io.error(`FAIL ${detail.title}\n${detail.body.join('\n')}\n`);
+                        continue;
+                    }
+                    const message = formatCliError(failure.error);
+                    this.io.error(`FAIL midscene-test: ${failure.source}:\n${message.split('\n').map((line)=>`  ${line}`).join('\n')}\n`);
+                }
+            }
+            this.log(`\n${this.footer(result.durationMs, result).join('\n')}`);
+            this.log('');
+            this.failures = [];
+        }
+        dispose() {
+            if (this.timer) clearInterval(this.timer);
+            if (this.scheduled) clearTimeout(this.scheduled);
+            this.timer = void 0;
+            this.scheduled = void 0;
+            this.removeResizeListener?.();
+            this.removeResizeListener = void 0;
+            this.progressView.clear();
+        }
+        constructor(io, mode = 'default'){
+            terminal_reporter_define_property(this, "io", void 0);
+            terminal_reporter_define_property(this, "mode", void 0);
+            terminal_reporter_define_property(this, "total", void 0);
+            terminal_reporter_define_property(this, "completionOrder", void 0);
+            terminal_reporter_define_property(this, "totalFiles", void 0);
+            terminal_reporter_define_property(this, "files", void 0);
+            terminal_reporter_define_property(this, "warnings", void 0);
+            terminal_reporter_define_property(this, "latestNotice", void 0);
+            terminal_reporter_define_property(this, "usage", void 0);
+            terminal_reporter_define_property(this, "finalMetrics", void 0);
+            terminal_reporter_define_property(this, "attempts", void 0);
+            terminal_reporter_define_property(this, "active", void 0);
+            terminal_reporter_define_property(this, "projectPhases", void 0);
+            terminal_reporter_define_property(this, "failures", void 0);
+            terminal_reporter_define_property(this, "lastOutput", void 0);
+            terminal_reporter_define_property(this, "startedAt", void 0);
+            terminal_reporter_define_property(this, "timer", void 0);
+            terminal_reporter_define_property(this, "scheduled", void 0);
+            terminal_reporter_define_property(this, "progressView", void 0);
+            terminal_reporter_define_property(this, "removeResizeListener", void 0);
+            terminal_reporter_define_property(this, "color", void 0);
+            this.io = io;
+            this.mode = mode;
+            this.total = 0;
+            this.completionOrder = 0;
+            this.totalFiles = 0;
+            this.files = new Map();
+            this.warnings = new Map();
+            this.usage = new CliModelUsage();
+            this.attempts = new Map();
+            this.active = new Map();
+            this.projectPhases = new Map();
+            this.failures = [];
+            this.lastOutput = Date.now();
+            this.startedAt = Date.now();
+            this.progressView = new TerminalProgress(io);
+            this.color = new (external_chalk_default()).Instance({
+                level: io.isTTY && !process.env.NO_COLOR ? 1 : 0
+            });
+        }
+    }
+    const escapeData = (text)=>text.replace(/%/g, '%25').replace(/\r/g, '%0D').replace(/\n/g, '%0A');
+    const escapeProperty = (text)=>escapeData(text).replace(/:/g, '%3A').replace(/,/g, '%2C');
+    const markdown = (text)=>text.replace(/[&<>`\r\n]/g, (char)=>({
+                '&': '&amp;',
+                '<': '&lt;',
+                '>': '&gt;',
+                '`': '&#96;',
+                '\r': ' ',
+                '\n': ' '
+            })[char]);
+    function githubFailureAnnotation(source, message, file) {
+        if ('true' !== process.env.GITHUB_ACTIONS) return;
+        const workspace = process.env.GITHUB_WORKSPACE ?? process.cwd();
+        const path = file ? (0, external_node_path_.relative)(workspace, (0, external_node_path_.resolve)(file)).split(external_node_path_.sep).join('/') : void 0;
+        return `::error ${path ? `file=${escapeProperty(path)},` : ''}title=${escapeProperty(source)}::${escapeData(message)}`;
+    }
+    function writeGitHubSummary(result) {
+        const output = process.env.GITHUB_STEP_SUMMARY;
+        if ('true' !== process.env.GITHUB_ACTIONS || !output) return;
+        const failedCases = [
+            ...new Map(result.cases.map((item)=>[
+                    item.caseId,
+                    item
+                ])).values()
+        ].filter((item)=>'failed' === item.status);
+        const summary = [
+            '## Midscene Test',
+            '',
+            '| Passed | Failed | Not run | Passed after retry | Duration |',
+            '| ---: | ---: | ---: | ---: | ---: |',
+            `| ${result.summary.passed} | ${result.summary.failed} | ${result.summary.notRun} | ${result.summary.passedAfterRetry} | ${formatDuration(result.durationMs)} |`,
+            '',
+            'Passed after retry is included in Passed.',
+            '',
+            ...failedCases.map((item)=>`- Failed: **${markdown(item.name)}** — ${markdown(item.projectName)}/\`${markdown(item.sourcePath)}\``),
+            ...result.summary.collectionErrors ? [
+                `- Collection errors: ${result.summary.collectionErrors}`
+            ] : [],
+            ...result.summary.documentFailures ? [
+                `- Failed files: ${result.summary.documentFailures}`
+            ] : [],
+            ...result.summary.projectFailures ? [
+                `- Failed projects: ${result.summary.projectFailures}`
+            ] : [],
+            '',
+            ...result.reportPath ? [
+                `Report artifact entry: \`${markdown(result.reportPath)}\``
+            ] : [],
+            `Structured results: \`${markdown(result.summaryPath)}\``,
+            ''
+        ].join('\n');
+        (0, external_node_fs_.appendFileSync)(output, `${summary}\n`);
+    }
     const v4_namespaceObject = require("zod/v4");
     const GENERATED_COMMENT = '<!-- Generated by `midscene-test nodes`. Do not edit directly. -->';
     const sortNodesForSpec = (nodes)=>{
@@ -233,7 +1249,32 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             warnings
         };
     };
-    const external_node_url_namespaceObject = require("node:url");
+    function captureTerminalOutput(output, streams = [
+        process.stdout,
+        process.stderr
+    ]) {
+        const cleanups = [];
+        for (const stream of streams){
+            const original = stream.write;
+            const forward = original.bind(stream);
+            const intercepted = (chunk, encoding, callback)=>{
+                const done = 'function' == typeof encoding ? encoding : callback;
+                const message = 'string' == typeof chunk ? chunk : Buffer.from(chunk).toString();
+                let accepted = true;
+                output(message, (text)=>{
+                    accepted = forward(text, done);
+                });
+                return accepted;
+            };
+            stream.write = intercepted;
+            cleanups.push(()=>{
+                if (stream.write === intercepted) stream.write = original;
+            });
+        }
+        return ()=>{
+            for (const cleanup of cleanups)cleanup();
+        };
+    }
     const api_namespaceObject = require("tsx/cjs/api");
     const NodeRegistry = test_runner_namespaceObject.NodeRegistry;
     const projectIdFromIndex = (index)=>`project-${index}`;
@@ -353,9 +1394,19 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         if (!Number.isInteger(value) || value < 0) throw new TypeError(`Midscene config ${label} must be a non-negative integer.`);
         return value;
     };
-    const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
+    const validateConcurrency = (value, label)=>{
+        if (null === value) return null;
+        return validatePositiveInteger(value, 1, label);
+    };
+    const validateFileConcurrency = (maxConcurrentFiles, fileSetup, label)=>{
+        if (maxConcurrentFiles > 1 && !fileSetup) throw new TypeError(`Midscene config ${label}.fileSetup is required when the effective maxConcurrentFiles is greater than 1.`);
+    };
+    const validateExecutionProjects = (value, defaultSetup, defaultFileSetup, globalNodes, test)=>{
         if (void 0 === value) {
             const setup = validateSetup(defaultSetup, 'setup');
+            const fileSetup = validateSetup(defaultFileSetup, 'fileSetup');
+            const maxConcurrentFiles = test.maxConcurrentFiles ?? 1 / 0;
+            validateFileConcurrency(maxConcurrentFiles, fileSetup, 'default');
             return {
                 hasExplicitProjects: false,
                 projects: Object.freeze([
@@ -365,6 +1416,10 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                         ...setup ? {
                             setup
                         } : {},
+                        ...fileSetup ? {
+                            fileSetup
+                        } : {},
+                        maxConcurrentFiles,
                         tags: Object.freeze({
                             include: [],
                             exclude: []
@@ -377,6 +1432,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             };
         }
         if (void 0 !== defaultSetup) throw new TypeError('Midscene config setup cannot be used together with projects. Move setup to projects[].setup.');
+        if (void 0 !== defaultFileSetup) throw new TypeError('Midscene config fileSetup cannot be used together with projects. Move fileSetup to projects[].fileSetup.');
         if (!Array.isArray(value) || 0 === value.length) throw new TypeError('Midscene config projects must be a non-empty array when declared.');
         const names = new Set();
         const projects = value.map((candidate, index)=>{
@@ -385,6 +1441,8 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             rejectUnknownKeys(candidate, [
                 'name',
                 'setup',
+                'fileSetup',
+                'maxConcurrentFiles',
                 'nodes',
                 'files',
                 'tags',
@@ -401,10 +1459,18 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 ...globalNodes.definitions().filter((node)=>!localNodes.has(node.name)),
                 ...localNodes.definitions()
             ]);
+            const fileSetup = validateSetup(candidate.fileSetup, `${label}.fileSetup`);
+            const globalFileLimit = test.maxConcurrentFiles ?? 1 / 0;
+            const maxConcurrentFiles = Math.min(globalFileLimit, validatePositiveInteger(candidate.maxConcurrentFiles, globalFileLimit, `${label}.maxConcurrentFiles`));
+            validateFileConcurrency(maxConcurrentFiles, fileSetup, label);
             return Object.freeze({
                 projectId: projectIdFromIndex(index),
                 name: candidate.name,
                 nodes,
+                ...fileSetup ? {
+                    fileSetup
+                } : {},
+                maxConcurrentFiles,
                 ...files ? {
                     files
                 } : {},
@@ -421,11 +1487,25 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             hasExplicitProjects: true
         };
     };
-    const validateTestOptions = (value)=>{
+    const validateTestOptions = (value, hasExplicitProjects)=>{
         if (void 0 !== value && !isRecord(value)) throw new TypeError('Midscene config test must be an object.');
         const candidate = value ?? {};
+        if (void 0 !== candidate.maxConcurrency) {
+            const limit = 'number' == typeof candidate.maxConcurrency && Number.isInteger(candidate.maxConcurrency) && candidate.maxConcurrency > 0 ? candidate.maxConcurrency : 1;
+            throw new TypeError([
+                'Midscene config test.maxConcurrency is no longer supported.',
+                'It controlled project concurrency, not file concurrency. Remove it and use:',
+                `  test: { maxConcurrentProjects: ${limit}, maxConcurrentFiles: ${hasExplicitProjects ? limit : 1} }`,
+                hasExplicitProjects ? '  Set projects[].maxConcurrentFiles to 1 to keep files sequential within each project.' : '  The implicit default project keeps running files sequentially.',
+                hasExplicitProjects ? 'For parallel files, configure fileSetup and raise both test.maxConcurrentFiles and projects[].maxConcurrentFiles.' : 'For parallel files, configure fileSetup and raise test.maxConcurrentFiles.',
+                'Migration guide: https://midscenejs.com/midscene-test/configuration.html#existing-configurations'
+            ].join('\n'));
+        }
         return Object.freeze({
-            maxConcurrency: validatePositiveInteger(candidate.maxConcurrency, 1, 'test.maxConcurrency'),
+            maxConcurrentFiles: validateConcurrency(candidate.maxConcurrentFiles, 'test.maxConcurrentFiles'),
+            maxConcurrentProjects: validateConcurrency(candidate.maxConcurrentProjects, 'test.maxConcurrentProjects'),
+            setupTimeout: validatePositiveInteger(candidate.setupTimeout, 120000, 'test.setupTimeout'),
+            teardownTimeout: validatePositiveInteger(candidate.teardownTimeout, 30000, 'test.teardownTimeout'),
             bail: validateNonNegativeInteger(candidate.bail, 0, 'test.bail'),
             testTimeout: validatePositiveInteger(candidate.testTimeout, 120000, 'test.testTimeout')
         });
@@ -455,16 +1535,18 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         if ('testRunner' in definition) throw new TypeError('Midscene config testRunner is not supported. Rename it to test.');
         rejectUnknownKeys(definition, [
             'setup',
+            'fileSetup',
             'projects',
             'test',
             'output',
             'nodes'
         ], 'root');
         const nodes = new NodeRegistry(definition.nodes);
-        const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, nodes);
+        const test = validateTestOptions(definition.test, void 0 !== definition.projects);
+        const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, definition.fileSetup, nodes, test);
         return {
             ...resolvedProjects,
-            test: validateTestOptions(definition.test),
+            test,
             output: validateOutput(definition.output),
             nodes,
             resolveNode: (name)=>nodes.get(name)
@@ -544,11 +1626,13 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                     start: state.position + sourceOffset,
                     end: 0,
                     value: null,
-                    children: []
+                    children: [],
+                    kind: null
                 });
                 const node = stack.pop();
                 node.end = state.position + sourceOffset;
                 node.value = state.result;
+                node.kind = state.kind;
                 stack.at(-1)?.children.push(node);
                 nodes.push(node);
                 if ('mapping' !== state.kind) return;
@@ -578,6 +1662,36 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         const value = (0, test_runner_namespaceObject.sanitizeReportText)(redacted, 65536);
         return {
             parsed,
+            locate (path) {
+                let node = nodes.at(-1);
+                for (const part of path){
+                    if (!node) return;
+                    while(1 === node.children.length && node.children[0].value === node.value)node = node.children[0];
+                    if ('number' == typeof part && 'sequence' === node.kind) node = node.children[part];
+                    else {
+                        if ('string' != typeof part || 'mapping' !== node.kind) return;
+                        const children = node.children;
+                        node = void 0;
+                        for(let index = 0; index < children.length; index += 2)if (children[index].value === part) {
+                            node = children[index + 1];
+                            break;
+                        }
+                    }
+                }
+                if (!node) return;
+                let start = node.start;
+                while(start < node.end)if (/\s/.test(source[start])) start++;
+                else if ('#' === source[start]) {
+                    const end = source.indexOf('\n', start);
+                    if (end < 0) return;
+                    start = end + 1;
+                } else break;
+                const prefix = source.slice(0, start).split(/\r\n|\r|\n/);
+                return {
+                    line: prefix.length,
+                    column: prefix.at(-1).length + 1
+                };
+            },
             sourceYaml: {
                 value,
                 ...redactedPaths.size ? {
@@ -636,7 +1750,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             ]));
         return value;
     };
-    function _define_property(obj, key, value) {
+    function collect_define_property(obj, key, value) {
         if (key in obj) Object.defineProperty(obj, key, {
             value: value,
             enumerable: true,
@@ -653,7 +1767,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 sourcePath,
                 actualFormat,
                 expectedFormat: 'native'
-            }), _define_property(this, "actualFormat", void 0);
+            }), collect_define_property(this, "actualFormat", void 0);
             this.actualFormat = actualFormat;
         }
     }
@@ -690,6 +1804,18 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         const sourcePath = source.sourcePath.split(external_node_path_.sep).join('/');
         const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
                 ...step,
+                meta: {
+                    ...step.meta,
+                    sourceLocation: snapshot.locate('steps' === phase ? [
+                        'cases',
+                        caseIndex,
+                        'steps',
+                        stepIndex
+                    ] : [
+                        phase,
+                        stepIndex
+                    ])
+                },
                 templateInput: step.input,
                 input: resolveWorkflowVariables(step.input, {
                     variables: options.variables,
@@ -865,6 +1991,9 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 markdown: relativeToSummary(result.summaryPath, result.markdownPath)
             } : {},
             summary: result.summary,
+            ...result.metrics ? {
+                metrics: result.metrics
+            } : {},
             projects: result.projects.map((project)=>({
                     projectId: project.projectId,
                     name: project.name,
@@ -1142,7 +2271,24 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 defaultTimeoutMs,
                 reportEnabled: true,
                 bindings: {
-                    resolveNode: project.nodes.require.bind(project.nodes)
+                    resolveNode: project.nodes.require.bind(project.nodes),
+                    ...project.fileSetup ? {
+                        documentSetup: {
+                            name: project.fileSetup.name,
+                            setup ({ projectContext, document, signal, onTeardown }) {
+                                return project.fileSetup.setup({
+                                    project,
+                                    projectContext,
+                                    file: document,
+                                    env: Object.freeze({
+                                        ...process.env
+                                    }),
+                                    signal,
+                                    onTeardown
+                                });
+                            }
+                        }
+                    } : {}
                 }
             });
         } catch (error) {
@@ -1244,14 +2390,14 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             preflightScope: hasFormatMismatch ? 'run' : 'project',
             reportEnabled: true,
             publications: [],
-            onProgress: options.onProgress ?? (()=>{})
+            onProgress: options.onProgress ?? (()=>{}),
+            onEvent: options.onEvent
         };
     }
     const external_node_events_namespaceObject = require("node:events");
     const report_namespaceObject = require("@midscene/core/report");
-    const logger_namespaceObject = require("@midscene/shared/logger");
     const result_markdown_text = (value)=>value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll('|', '&#124;').replaceAll('[', '&#91;').replaceAll(']', '&#93;').replaceAll('*', '&#42;').replaceAll('_', '&#95;').replaceAll('`', '&#96;').replaceAll('\\', '&#92;').replace(/[\r\n]+/g, ' ');
-    const duration = (ms)=>{
+    const result_markdown_duration = (ms)=>{
         const seconds = Math.round(ms / 1000);
         return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
     };
@@ -1262,7 +2408,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         const lines = [
             '## Midscene Test',
             '',
-            `${outcome} · ${duration(dump.durationMs)}`,
+            `${outcome} · ${result_markdown_duration(dump.durationMs)}`,
             ''
         ];
         if (summary.filtered) lines.push(`**Filtered:** ${summary.filtered}`, '');
@@ -1325,6 +2471,38 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         }));
         return output;
     }
+    function scopeNodeConsole(node) {
+        return {
+            ...node,
+            execute (ctx) {
+                const position = 'case' === ctx.scope ? ctx.case : ctx.document;
+                const scope = {
+                    projectName: position.projectName,
+                    sourcePath: position.sourcePath,
+                    ...'case' === ctx.scope ? {
+                        caseId: ctx.case.caseId,
+                        caseName: ctx.case.name,
+                        runId: ctx.case.runId
+                    } : {
+                        runId: ctx.document.documentRunId
+                    },
+                    phase: position.phase,
+                    stepIndex: position.stepIndex,
+                    node: node.name
+                };
+                return (0, logger_namespaceObject.runWithConsoleLogScope)(scope, ()=>node.execute({
+                        ...ctx,
+                        onTeardown (teardown) {
+                            ctx.onTeardown(()=>(0, logger_namespaceObject.runWithConsoleLogScope)({
+                                    ...scope,
+                                    phase: 'teardown',
+                                    stepIndex: void 0
+                                }, teardown));
+                        }
+                    }));
+            }
+        };
+    }
     const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
     const formatStep = (info)=>{
         const position = stepPosition(info);
@@ -1348,59 +2526,149 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             ...result.beforeAll,
             ...result.afterAll
         ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (result.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError) || !!result.executionErrors?.some(test_runner_namespaceObject.isResourceRecoveryError);
+    const isSharedResourceFailure = (error)=>{
+        const seen = new Set();
+        const pending = [
+            error
+        ];
+        while(pending.length && seen.size < 50){
+            const item = pending.pop();
+            if ('object' != typeof item || null === item || seen.has(item)) continue;
+            seen.add(item);
+            const failure = item;
+            if ('PROJECT_RESOURCE_ERROR' === failure.code) return true;
+            if (failure.cause) pending.push(failure.cause);
+            if (Array.isArray(failure.errors)) pending.push(...failure.errors.slice(0, 50));
+        }
+        return false;
+    };
     async function executeDocumentInvocation(options) {
         const { invocation, project, sinks } = options;
+        const isProjectResourceFailure = options.isProjectResourceFailure ?? (()=>false);
         const { document } = invocation;
         const documentRetry = 'document' === invocation.retry.scope;
         const attempts = [];
+        const fileSetup = invocation.bindings.documentSetup;
+        const documentSetup = fileSetup ? {
+            ...fileSetup,
+            setup (ctx) {
+                const scope = {
+                    projectName: project.name,
+                    sourcePath: document.sourcePath,
+                    runId: ctx.document.documentRunId,
+                    phase: 'fileSetup'
+                };
+                return (0, logger_namespaceObject.runWithConsoleLogScope)(scope, async ()=>{
+                    try {
+                        return await fileSetup.setup({
+                            ...ctx,
+                            onTeardown (teardown) {
+                                ctx.onTeardown(()=>(0, logger_namespaceObject.runWithConsoleLogScope)({
+                                        ...scope,
+                                        phase: 'teardown'
+                                    }, teardown));
+                            }
+                        });
+                    } catch (error) {
+                        if (isProjectResourceFailure(error)) options.markProjectFatal();
+                        throw error;
+                    }
+                });
+            }
+        } : void 0;
+        options.onEvent?.({
+            type: 'document-start',
+            documentId: document.documentId,
+            projectName: project.name,
+            sourcePath: document.sourcePath,
+            cases: document.cases.length
+        });
         await (0, test_runner_namespaceObject.runDocumentAttempts)({
             retry: documentRetry ? invocation.retry.count : 0,
             signal: options.signal,
             shouldStop: ()=>options.shouldBail() || options.isProjectFatal()
         }, async (documentAttemptIndex)=>{
             if (documentRetry) options.onProgress(`    file attempt ${documentAttemptIndex + 1}/${invocation.retry.count + 1}: ${document.sourcePath}`);
-            const execution = await (0, test_runner_namespaceObject.runWorkflowDocument)(document, {
-                plan: invocation.plan,
-                documentAttemptIndex: documentRetry ? documentAttemptIndex : void 0,
-                ...invocation.bindings,
-                project,
-                projectContext: options.projectContext,
-                retry: documentRetry ? 0 : invocation.retry.count,
-                signal: options.signal,
-                defaultTimeoutMs: invocation.defaultTimeoutMs,
-                shouldStop: ()=>options.rootSignal.aborted || options.shouldBail() || options.isProjectFatal(),
-                stopReason: ()=>options.rootSignal.aborted ? 'interrupted' : options.isProjectFatal() ? 'fatal-error' : 'bail',
-                isFatalError: (run)=>[
-                        ...run.beforeEach,
-                        ...run.steps,
-                        ...run.afterEach
-                    ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (run.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError),
-                onCaseStart: (collectedCase)=>{
-                    options.onProgress(`    [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
-                },
-                onStepStart: (info)=>{
-                    const indent = 'case' === info.scope ? '      ' : '    ';
-                    options.onProgress(`${indent}→ ${formatStep(info)}`);
-                },
-                onStepResult: async (info, result)=>{
-                    await invocation.bindings.onStepResult?.(info, result);
-                    options.onProgress(formatStepResult(info, result));
-                },
-                onCaseResult: async (attempt)=>{
-                    await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
-                    options.onProgress(`    ${'success' === attempt.status ? '✓' : '✗'} attempt ${attempt.attemptIndex + 1}/${documentRetry ? 1 : invocation.retry.count + 1}: ${attempt.name} (${attempt.durationMs} ms)`);
-                },
-                onCaseOutcome: (outcome)=>{
-                    if (caseHasFatalError(outcome)) options.markProjectFatal();
-                    if (!documentRetry && 'failed' === outcome.status) options.addFailedCases(1);
-                },
-                onDocumentResult: options.onDocumentResult
-            }).catch(async (error)=>{
+            const execution = await (0, logger_namespaceObject.runWithConsoleLogScope)({
+                projectName: project.name,
+                sourcePath: document.sourcePath
+            }, ()=>(0, test_runner_namespaceObject.runWorkflowDocument)(document, {
+                    plan: invocation.plan,
+                    documentAttemptIndex: documentRetry ? documentAttemptIndex : void 0,
+                    ...invocation.bindings,
+                    resolveNode: (name)=>scopeNodeConsole(invocation.bindings.resolveNode(name)),
+                    documentSetup,
+                    setupTimeoutMs: options.setupTimeoutMs,
+                    teardownTimeoutMs: options.teardownTimeoutMs,
+                    project,
+                    projectContext: options.projectContext,
+                    retry: documentRetry ? 0 : invocation.retry.count,
+                    signal: options.signal,
+                    defaultTimeoutMs: invocation.defaultTimeoutMs,
+                    shouldStop: ()=>options.rootSignal.aborted || options.shouldBail() || options.isProjectFatal(),
+                    stopReason: ()=>options.rootSignal.aborted ? 'interrupted' : options.isProjectFatal() ? 'fatal-error' : 'bail',
+                    isFatalError: (run)=>[
+                            ...run.beforeEach,
+                            ...run.steps,
+                            ...run.afterEach
+                        ].some((step)=>step.error && ((0, test_runner_namespaceObject.isFatalDeviceError)(step.error) || isProjectResourceFailure(step.error))) || (run.teardownErrors ?? []).some((error)=>(0, test_runner_namespaceObject.isFatalDeviceError)(error) || isProjectResourceFailure(error)),
+                    onCaseStart: (collectedCase)=>{
+                        options.onProgress(`    [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
+                    },
+                    onStepStart: (info)=>{
+                        options.onEvent?.({
+                            type: 'step-start',
+                            projectName: project.name,
+                            info
+                        });
+                        const indent = 'case' === info.scope ? '      ' : '    ';
+                        options.onProgress(`${indent}→ ${formatStep(info)}`);
+                    },
+                    onStepResult: async (info, result)=>{
+                        if (isProjectResourceFailure(result.error)) options.markProjectFatal();
+                        await invocation.bindings.onStepResult?.(info, result);
+                        options.onProgress(formatStepResult(info, result));
+                        options.onEvent?.({
+                            type: 'step-end',
+                            projectName: project.name,
+                            info,
+                            result
+                        });
+                    },
+                    onCaseResult: async (attempt)=>{
+                        await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
+                        options.onProgress(`    ${'success' === attempt.status ? '✓' : '✗'} case attempt ${attempt.attemptIndex + 1}/${documentRetry ? 1 : invocation.retry.count + 1}: ${attempt.name} (${attempt.durationMs} ms)`);
+                        if (!documentRetry) options.onEvent?.({
+                            type: 'case-attempt-end',
+                            attempt,
+                            maxAttempts: invocation.retry.count + 1
+                        });
+                    },
+                    onCaseOutcome: (outcome)=>{
+                        if (documentRetry) options.onEvent?.({
+                            type: 'case-progress',
+                            outcome,
+                            documentAttemptIndex
+                        });
+                        else options.onEvent?.({
+                            type: 'case-end',
+                            outcome
+                        });
+                        if (outcome.attempts?.some((attempt)=>[
+                                ...attempt.beforeEach,
+                                ...attempt.steps,
+                                ...attempt.afterEach
+                            ].some((step)=>isProjectResourceFailure(step.error)) || attempt.teardownErrors?.some(isProjectResourceFailure))) options.markProjectFatal();
+                        if (!options.isolatedContext && caseHasFatalError(outcome)) options.markProjectFatal();
+                        if (!documentRetry && 'failed' === outcome.status) options.addFailedCases(1);
+                    },
+                    onDocumentResult: options.onDocumentResult
+                })).catch(async (error)=>{
                 if (error instanceof test_runner_namespaceObject.WorkflowExecutionFailure) {
                     const partial = error.result;
                     const resourceOnly = error.errors.length > 0 && error.errors.every((failure)=>(0, test_runner_namespaceObject.isResourceRecoveryError)(failure) || partial.document.hostErrors?.some((host)=>'cleanup' === host.phase && (host.error === failure || host.error instanceof Error && host.error.cause === failure)));
                     if (resourceOnly) {
-                        if (error.errors.some(test_runner_namespaceObject.isResourceRecoveryError)) options.markProjectFatal();
+                        if (!options.isolatedContext && error.errors.some(test_runner_namespaceObject.isResourceRecoveryError)) options.markProjectFatal();
                         return partial;
                     }
                     if (documentRetry) partial.document.retryDecision = (0, test_runner_namespaceObject.decideRetry)({
@@ -1429,7 +2697,17 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 }
                 throw error;
             });
-            if (documentHasFatalError(execution.document)) options.markProjectFatal();
+            if (!options.isolatedContext && documentHasFatalError(execution.document)) options.markProjectFatal();
+            if ([
+                ...execution.document.beforeAll,
+                ...execution.document.afterAll,
+                ...(execution.document.hostErrors ?? []).map(({ error })=>({
+                        error
+                    })),
+                ...(execution.document.teardownErrors ?? []).map((error)=>({
+                        error
+                    }))
+            ].some(({ error })=>isProjectResourceFailure(error))) options.markProjectFatal();
             const owners = [
                 execution.document,
                 ...execution.cases.flatMap((outcome)=>outcome.attempts ?? [])
@@ -1437,7 +2715,10 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             const cleanupPending = owners.some((owner)=>owner.cleanup?.status === 'pending');
             const operationPending = owners.some((owner)=>!!owner.pendingOperations?.length);
             const cleanupFailed = owners.some((owner)=>owner.cleanup?.status === 'failed' || !!owner.teardownErrors?.length || 'hostErrors' in owner && owner.hostErrors?.some(({ phase })=>'cleanup' === phase));
-            if (cleanupPending || cleanupFailed || operationPending) options.markProjectFatal();
+            if (cleanupPending || operationPending) {
+                options.markProjectFatal();
+                options.onUnresolvedResources?.();
+            } else if (cleanupFailed && !options.isolatedContext) options.markProjectFatal();
             const failed = 'failed' === execution.document.status || execution.cases.some((item)=>'success' !== item.status);
             const decision = (0, test_runner_namespaceObject.decideRetry)({
                 scope: 'document',
@@ -1452,6 +2733,11 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 shouldStop: options.shouldBail()
             });
             if (documentRetry) execution.document.retryDecision = decision;
+            if (documentRetry && 'retry' === decision.decision) options.onEvent?.({
+                type: 'document-retry',
+                document: execution.document,
+                maxAttempts: invocation.retry.count + 1
+            });
             attempts.push(execution);
             sinks.cases.push(...execution.cases.map((outcome)=>({
                     ...outcome,
@@ -1486,10 +2772,280 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         });
         const final = attempts.at(-1);
         if (!final) return;
+        if (documentRetry) for (const outcome of final.cases)options.onEvent?.({
+            type: 'case-end',
+            outcome,
+            documentRetries: attempts.length - 1
+        });
         const failedCases = final.cases.filter((item)=>'failed' === item.status).length;
+        options.onEvent?.({
+            type: 'document-end',
+            document: final.document,
+            cases: final.cases,
+            durationMs: attempts.reduce((total, attempt)=>total + attempt.document.durationMs, 0)
+        });
         if (documentRetry && failedCases) options.addFailedCases(failedCases);
         else if ('failed' === final.document.status && 0 === failedCases) options.addFailedCases(Math.max(1, failedCases));
     }
+    async function runPreparedFiles(options) {
+        const states = options.projects.map((prepared)=>({
+                prepared,
+                cases: [],
+                documents: [],
+                cursor: 0,
+                active: 0,
+                initializing: false,
+                finished: false,
+                fatal: false,
+                setupFailed: false
+            }));
+        let nextProject = 0;
+        let resourcesUnresolved = false;
+        let occupied = 0;
+        let occupiedProjects = 0;
+        const cleanupQueue = [];
+        const release = ()=>{
+            occupied--;
+            while(occupied < options.maxConcurrentFiles && cleanupQueue.length){
+                occupied++;
+                cleanupQueue.shift()();
+            }
+            wake?.();
+        };
+        let wake;
+        const running = new Set();
+        const stopped = (state)=>options.signal.aborted || options.shouldBail() || state.fatal;
+        const invalid = (state)=>options.preflightFailed || state.prepared.collectionErrors.length > 0;
+        const unresolved = ()=>{
+            if (resourcesUnresolved) return;
+            resourcesUnresolved = true;
+            options.onInfrastructureError(new test_runner_namespaceObject.WorkflowError('Resources are still running or cleanup is pending. No new test files will start.', {
+                code: 'UNRESOLVED_FILE_RESOURCES'
+            }));
+        };
+        const finalizeProject = (state)=>{
+            const { prepared } = state;
+            const completed = new Set(state.cases.map((item)=>item.caseId));
+            const reason = invalid(state) ? 'project-preflight-failed' : state.setupFailed ? 'project-setup-failed' : options.signal.aborted ? 'interrupted' : state.fatal ? 'fatal-error' : 'bail';
+            for (const document of prepared.documents)for (const item of document.cases)if (!completed.has(item.caseId)) state.cases.push({
+                documentId: document.documentId,
+                caseId: item.caseId,
+                projectName: prepared.project.name,
+                name: item.definition.name,
+                sourcePath: item.sourcePath,
+                caseIndex: item.caseIndex,
+                status: 'not-run',
+                notRunReason: reason
+            });
+            const order = new Map(prepared.documents.map((document, i)=>[
+                    document.documentId,
+                    i
+                ]));
+            const position = (id)=>order.get(id) ?? Number.MAX_SAFE_INTEGER;
+            state.cases.sort((a, b)=>position(a.documentId) - position(b.documentId) || a.caseIndex - b.caseIndex);
+            state.documents.sort((a, b)=>position(a.documentId) - position(b.documentId));
+        };
+        const finishProject = async (state)=>{
+            if (!state.runtime || state.finished) return;
+            state.finished = true;
+            try {
+                options.onEvent?.({
+                    type: 'project-phase',
+                    projectName: state.prepared.project.name,
+                    phase: 'teardown'
+                });
+            } catch (error) {
+                options.onInfrastructureError(error);
+            }
+            const failed = state.fatal || options.signal.aborted || state.cases.some((item)=>'success' !== item.status) || state.documents.some((item)=>'success' !== item.status);
+            state.lifecycle = await (0, logger_namespaceObject.runWithConsoleLogScope)({
+                projectName: state.prepared.project.name,
+                phase: 'teardown'
+            }, ()=>state.runtime.finish(failed ? 'failed' : 'success'));
+            const releaseProject = ()=>{
+                occupiedProjects--;
+                wake?.();
+            };
+            if (state.lifecycle.cleanup?.status === 'pending' || state.lifecycle.pendingOperations?.length) {
+                unresolved();
+                Promise.all([
+                    (0, test_runner_namespaceObject.waitForScopeOperations)(state.runtime.signal),
+                    (0, test_runner_namespaceObject.getResourceCleanupCompletion)(state.runtime.signal)
+                ]).then(releaseProject, (error)=>{
+                    options.onInfrastructureError(error);
+                    releaseProject();
+                });
+            } else {
+                releaseProject();
+                finalizeProject(state);
+                options.onProjectEnd?.(state);
+            }
+        };
+        const admit = ()=>{
+            for(let offset = 0; offset < states.length; offset++){
+                const index = (nextProject + offset) % states.length;
+                const state = states[index];
+                if (invalid(state) || state.finished || state.initializing) continue;
+                if (!state.runtime && occupiedProjects >= options.maxConcurrentProjects) continue;
+                const cleanupOnly = !!state.runtime && 0 === state.active && (stopped(state) || state.cursor === state.prepared.invocations.length);
+                if (!cleanupOnly && (stopped(state) || state.cursor >= state.prepared.invocations.length || state.active >= (state.prepared.project.maxConcurrentFiles ?? options.maxConcurrentFiles))) continue;
+                nextProject = (index + 1) % states.length;
+                occupied++;
+                state.active++;
+                if (!state.runtime && !cleanupOnly) {
+                    occupiedProjects++;
+                    state.initializing = true;
+                }
+                const invocationIndex = cleanupOnly ? -1 : state.cursor++;
+                return {
+                    state,
+                    index,
+                    invocationIndex
+                };
+            }
+        };
+        const run = async ({ state, index, invocationIndex })=>{
+            const { prepared } = state;
+            const { project } = prepared;
+            let fileResourcesPending = false;
+            try {
+                if (invocationIndex < 0) return void await finishProject(state);
+                if (!state.runtime) {
+                    state.runtime = (0, test_runner_namespaceObject.createProjectRuntime)({
+                        project,
+                        setup: project.setup,
+                        signal: options.signal,
+                        setupTimeoutMs: options.setupTimeoutMs,
+                        teardownTimeoutMs: options.teardownTimeoutMs
+                    });
+                    (0, external_node_events_namespaceObject.setMaxListeners)(Math.max(10, Math.min(prepared.invocations.length, project.maxConcurrentFiles ?? options.maxConcurrentFiles) + 1), state.runtime.signal);
+                    options.announceProject(prepared, index);
+                    options.onEvent?.({
+                        type: 'project-phase',
+                        projectName: project.name,
+                        phase: 'setup'
+                    });
+                    await (0, logger_namespaceObject.runWithConsoleLogScope)({
+                        projectName: project.name,
+                        phase: 'setup'
+                    }, ()=>state.runtime.start());
+                    options.onEvent?.({
+                        type: 'project-phase',
+                        projectName: project.name,
+                        phase: 'running'
+                    });
+                    state.initializing = false;
+                    if (!state.runtime.canRun) {
+                        state.fatal = true;
+                        state.setupFailed = true;
+                    }
+                    wake?.();
+                }
+                if (stopped(state)) return;
+                const invocation = prepared.invocations[invocationIndex];
+                options.onProgress(prepared, `  [document ${invocationIndex + 1}/${prepared.invocations.length}] ${invocation.document.sourcePath}`);
+                await executeDocumentInvocation({
+                    invocation,
+                    project,
+                    projectContext: state.runtime.context,
+                    runDir: options.runDir,
+                    signal: state.runtime.signal,
+                    rootSignal: options.signal,
+                    shouldBail: options.shouldBail,
+                    isProjectFatal: ()=>state.fatal,
+                    markProjectFatal: ()=>{
+                        if (state.fatal) return;
+                        state.fatal = true;
+                        state.runtime?.abort(new test_runner_namespaceObject.WorkflowError(`Project "${project.name}" shared execution environment is unavailable.`, {
+                            code: 'PROJECT_RESOURCE_ERROR'
+                        }));
+                    },
+                    addFailedCases: options.addFailedCases,
+                    onProgress: (message)=>options.onProgress(prepared, options.maxConcurrentFiles > 1 ? ` [${invocation.document.sourcePath}]${message}` : message),
+                    sinks: state,
+                    onEvent: options.onEvent,
+                    isolatedContext: void 0 !== project.fileSetup,
+                    isProjectResourceFailure: isSharedResourceFailure,
+                    setupTimeoutMs: options.setupTimeoutMs,
+                    teardownTimeoutMs: options.teardownTimeoutMs,
+                    onUnresolvedResources: ()=>{
+                        fileResourcesPending = true;
+                        unresolved();
+                    }
+                });
+            } catch (error) {
+                state.fatal = true;
+                fileResourcesPending = !!state.runtime && (0, test_runner_namespaceObject.getPendingScopeOperations)(state.runtime.signal).length > 0;
+                options.onInfrastructureError(error);
+            } finally{
+                state.initializing = false;
+                try {
+                    if (1 === state.active && (stopped(state) || state.cursor === prepared.invocations.length)) await finishProject(state);
+                } catch (error) {
+                    options.onInfrastructureError(error);
+                }
+                state.active--;
+                if (state.runtime && (fileResourcesPending || state.lifecycle?.cleanup?.status === 'pending')) (0, test_runner_namespaceObject.waitForScopeOperations)(state.runtime.signal).then(release, (error)=>{
+                    options.onInfrastructureError(error);
+                    release();
+                });
+                else release();
+                wake?.();
+            }
+        };
+        while(true){
+            const changed = new Promise((resolve)=>{
+                wake = resolve;
+            });
+            while(occupied < options.maxConcurrentFiles){
+                const job = admit();
+                if (!job) break;
+                const task = run(job);
+                running.add(task);
+                const settled = ()=>{
+                    running.delete(task);
+                    wake?.();
+                };
+                task.then(settled, (error)=>{
+                    options.onInfrastructureError(error);
+                    settled();
+                });
+            }
+            if (!running.size) break;
+            await changed;
+        }
+        wake = void 0;
+        await Promise.all(states.map(async (state)=>{
+            if (!state.runtime || state.finished) return;
+            const admission = new Promise((resolve)=>{
+                cleanupQueue.push(resolve);
+            });
+            (0, test_runner_namespaceObject.trackResourceOperation)({}, admission, state.runtime.signal);
+            while(occupied < options.maxConcurrentFiles && cleanupQueue.length){
+                occupied++;
+                cleanupQueue.shift()();
+            }
+            try {
+                await finishProject(state);
+            } catch (error) {
+                options.onInfrastructureError(error);
+            } finally{
+                Promise.all([
+                    admission,
+                    (0, test_runner_namespaceObject.getResourceCleanupCompletion)(state.runtime.signal)
+                ]).then(release, (error)=>{
+                    options.onInfrastructureError(error);
+                    release();
+                });
+            }
+        }));
+        for (const state of states){
+            const { prepared } = state;
+            if (!state.runtime) options.announceProject(prepared, states.indexOf(state));
+            finalizeProject(state);
+        }
+        return states;
+    }
     function createOperationJournal(runDir) {
         const path = (0, external_node_path_.join)(runDir, 'operations.jsonl');
         (0, external_node_fs_.writeFileSync)(path, '', {
@@ -1558,8 +3114,34 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         const totalDocuments = preparedProjects.reduce((total, prepared)=>total + prepared.documents.length, 0);
         const totalCases = preparedProjects.reduce((total, prepared)=>total + prepared.selectedCaseCount, 0);
         const totalErrors = preparedProjects.reduce((total, prepared)=>total + prepared.collectionErrors.length, 0);
+        plan.onEvent?.({
+            type: 'run-start',
+            configuredModels: configuredModelNames(),
+            projects: preparedProjects.length,
+            documents: totalDocuments + totalErrors,
+            cases: totalCases,
+            projectRoot,
+            configPath,
+            startedAt: startedAt.toISOString(),
+            maxConcurrentProjects: definition.test.maxConcurrentProjects,
+            maxConcurrentFiles: definition.test.maxConcurrentFiles,
+            files: preparedProjects.flatMap((prepared)=>[
+                    ...prepared.documents.map((document)=>({
+                            documentId: document.documentId,
+                            projectName: prepared.project.name,
+                            sourcePath: document.sourcePath,
+                            cases: document.cases.length
+                        })),
+                    ...prepared.collectionErrors.map((error)=>({
+                            documentId: error.sourcePath,
+                            projectName: prepared.project.name,
+                            sourcePath: error.sourcePath,
+                            cases: 0
+                        }))
+                ])
+        });
         progress(`midscene-test: preflighted ${preparedProjects.length} projects, ${totalDocuments} documents, ${totalCases} cases, ${totalErrors} collection errors`);
-        const effectiveConcurrency = Math.min(definition.test.maxConcurrency, preparedProjects.length);
+        const effectiveConcurrency = Math.min(definition.test.maxConcurrentFiles ?? 1 / 0, Math.max(1, totalDocuments));
         await writeTestRunPlan(runDir, preparedProjects);
         const journal = createOperationJournal(runDir);
         const rootController = new AbortController();
@@ -1573,6 +3155,18 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         process.on('SIGTERM', sigterm);
         let failedCaseCount = 0;
         const bailReached = ()=>definition.test.bail > 0 && failedCaseCount >= definition.test.bail;
+        let shutdownDeadline;
+        const beginShutdown = ()=>{
+            shutdownDeadline ??= Date.now() + definition.test.teardownTimeout;
+        };
+        rootController.signal.addEventListener('abort', beginShutdown, {
+            once: true
+        });
+        const addFailedCases = (count)=>{
+            failedCaseCount += count;
+            if (bailReached()) beginShutdown();
+        };
+        const teardownTimeoutMs = ()=>Math.max(0, Math.min(definition.test.teardownTimeout, void 0 === shutdownDeadline ? 1 / 0 : shutdownDeadline - Date.now()));
         let hasInfrastructureError = false;
         const infrastructureErrors = [];
         const recordInfrastructureError = (error)=>{
@@ -1634,112 +3228,30 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             announceProject(prepared, projectIndex);
             return buildProjectResult(prepared, notRunSuite(prepared, reason), []);
         };
-        const runPreparedProject = async (prepared, projectIndex)=>{
-            const { project } = prepared;
-            announceProject(prepared, projectIndex);
-            const projectProgress = (message)=>runInfrastructureCallback(()=>progress(effectiveConcurrency > 1 ? `[${project.name}]${message}` : message));
-            const cases = [];
-            const documents = [];
-            let lifecycle;
-            let projectFatal = false;
-            if (prepared.collectionErrors.length > 0 || 'run' === plan.preflightScope && totalErrors > 0) cases.push(...notRunSuite(prepared, 'project-preflight-failed'));
-            else if (rootController.signal.aborted) cases.push(...notRunSuite(prepared, 'interrupted'));
-            else if (bailReached()) cases.push(...notRunSuite(prepared, 'bail'));
-            else {
-                const runtime = (0, test_runner_namespaceObject.createProjectRuntime)({
-                    project,
-                    setup: project.setup,
-                    signal: rootController.signal
-                });
-                let hasProjectExecutionError = false;
-                try {
-                    await runtime.start();
-                    if (runtime.canRun) {
-                        const runDocument = async (invocation, documentIndex)=>{
-                            const { document } = invocation;
-                            if (rootController.signal.aborted || bailReached() || projectFatal) {
-                                const reason = rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
-                                cases.push(...document.cases.map((item)=>asNotRun(document.documentId, item, project.name, reason)));
-                                return;
-                            }
-                            projectProgress(`  [document ${documentIndex + 1}/${prepared.documents.length}] ${document.sourcePath}`);
-                            await executeDocumentInvocation({
-                                invocation,
-                                project,
-                                projectContext: runtime.context,
-                                runDir,
-                                signal: runtime.signal,
-                                rootSignal: rootController.signal,
-                                shouldBail: bailReached,
-                                isProjectFatal: ()=>projectFatal,
-                                markProjectFatal: ()=>{
-                                    projectFatal = true;
-                                },
-                                addFailedCases: (count)=>{
-                                    failedCaseCount += count;
-                                },
-                                onProgress: projectProgress,
-                                sinks: {
-                                    cases,
-                                    documents
-                                }
-                            });
-                        };
-                        let prerequisiteFailed = false;
-                        const prerequisite = prepared.invocations.find((invocation)=>invocation.document.documentId === prepared.prerequisiteDocumentId);
-                        const prerequisiteCount = prerequisite ? 1 : 0;
-                        if (prerequisite) {
-                            await runDocument(prerequisite, 0);
-                            prerequisiteFailed = documents.at(-1)?.status === 'failed' || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status);
-                        }
-                        if (!prerequisiteFailed) await (0, test_runner_namespaceObject.runConcurrentJobs)(prepared.invocations.filter((invocation)=>invocation !== prerequisite), {
-                            concurrency: prepared.documentConcurrency,
-                            shouldStop: ()=>rootController.signal.aborted || bailReached() || projectFatal
-                        }, async (invocation, index)=>{
-                            try {
-                                await runDocument(invocation, index + prerequisiteCount);
-                            } catch (error) {
-                                recordInfrastructureError(error);
-                                throw error;
-                            }
-                        });
-                        const completed = new Set(cases.map((item)=>item.caseId));
-                        const reason = prerequisiteFailed ? 'project-setup-failed' : rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
-                        cases.push(...notRunSuite(prepared, reason).filter((item)=>!completed.has(item.caseId)));
-                    } else cases.push(...notRunSuite(prepared, rootController.signal.aborted ? 'interrupted' : 'project-setup-failed'));
-                } catch (error) {
-                    hasProjectExecutionError = true;
-                    recordInfrastructureError(error);
-                } finally{
-                    const hasFailure = hasProjectExecutionError || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status) || latestById(documents, (item)=>item.documentId).some((item)=>'failed' === item.status) || projectFatal || rootController.signal.aborted;
-                    lifecycle = await runtime.finish(hasFailure ? 'failed' : 'success');
-                }
-                if (hasProjectExecutionError) {
-                    const completed = new Set(cases.map((item)=>item.caseId));
-                    cases.push(...notRunSuite(prepared, 'interrupted').filter((item)=>!completed.has(item.caseId)));
-                }
-            }
-            const order = new Map(prepared.documents.map((document, index)=>[
-                    document.documentId,
-                    index
-                ]));
-            const documentOrder = (id)=>order.get(id) ?? Number.MAX_SAFE_INTEGER;
-            cases.sort((a, b)=>documentOrder(a.documentId) - documentOrder(b.documentId) || a.caseIndex - b.caseIndex);
-            documents.sort((a, b)=>documentOrder(a.documentId) - documentOrder(b.documentId) || (a.attemptIndex ?? 0) - (b.attemptIndex ?? 0));
-            return buildProjectResult(prepared, cases, documents, lifecycle);
-        };
         const projectResults = new Array(preparedProjects.length);
         try {
-            await (0, test_runner_namespaceObject.runConcurrentJobs)(preparedProjects, {
-                concurrency: effectiveConcurrency,
-                shouldStop: ()=>hasInfrastructureError || rootController.signal.aborted || bailReached()
-            }, async (prepared, index)=>{
-                try {
-                    projectResults[index] = await runPreparedProject(prepared, index);
-                } catch (error) {
-                    recordInfrastructureError(error);
-                    throw error;
-                }
+            const states = await runPreparedFiles({
+                projects: preparedProjects,
+                maxConcurrentFiles: effectiveConcurrency,
+                maxConcurrentProjects: definition.test.maxConcurrentProjects ?? 1 / 0,
+                setupTimeoutMs: definition.test.setupTimeout,
+                teardownTimeoutMs,
+                signal: rootController.signal,
+                runDir,
+                preflightFailed: 'run' === plan.preflightScope && totalErrors > 0,
+                shouldBail: bailReached,
+                addFailedCases,
+                announceProject,
+                onProgress: (prepared, message)=>runInfrastructureCallback(()=>progress(preparedProjects.length > 1 || effectiveConcurrency > 1 ? `[${prepared.project.name}]${message}` : message)),
+                onEvent: (event)=>runInfrastructureCallback(()=>plan.onEvent?.(event)),
+                onProjectEnd: (state)=>runInfrastructureCallback(()=>plan.onEvent?.({
+                            type: 'project-end',
+                            project: buildProjectResult(state.prepared, state.cases, state.documents, state.lifecycle)
+                        })),
+                onInfrastructureError: recordInfrastructureError
+            });
+            states.forEach((state, index)=>{
+                projectResults[index] = buildProjectResult(state.prepared, state.cases, state.documents, state.lifecycle);
             });
         } catch (error) {
             recordInfrastructureError(error);
@@ -1816,6 +3328,10 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                     buildRunnerDump: (index)=>{
                         reportIndex = index;
                         const dump = (0, test_runner_namespaceObject.buildTestRunReportDump)(completedResult, index);
+                        completedResult = {
+                            ...completedResult,
+                            metrics: dump.metrics
+                        };
                         const warn = (0, logger_namespaceObject.getDebug)('test-runner:report-assembler', {
                             console: true
                         });
@@ -1833,6 +3349,16 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             await publication.publish(completedResult);
         });
         await publish('write-result', (0, external_node_path_.join)((0, external_node_path_.dirname)(summaryPath), 'result.md'), async ()=>{
+            if (!completedResult.metrics) {
+                const dump = (0, test_runner_namespaceObject.buildTestRunReportDump)(completedResult, reportIndex ?? {
+                    sources: [],
+                    metrics: (0, test_runner_namespaceObject.sumTestRunReportMetrics)([])
+                });
+                completedResult = {
+                    ...completedResult,
+                    metrics: dump.metrics
+                };
+            }
             const markdownPath = await writeTestResultMarkdown(completedResult, reportIndex);
             completedResult = {
                 ...completedResult,
@@ -1853,6 +3379,7 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
         let configPath;
         let resultDir;
         const projectNames = [];
+        let reporter;
         for(let index = commandOffset; index < args.length; index += 1){
             const token = args[index];
             const equal = token.startsWith('-') ? token.indexOf('=') : -1;
@@ -1863,16 +3390,21 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
                 projectRoot = (0, external_node_path_.resolve)(cwd, arg);
                 continue;
             }
-            if ('--config' === arg || '--result-dir' === arg || '--project' === arg) {
+            if ('--config' === arg || '--result-dir' === arg || '--project' === arg || '--reporter' === arg) {
                 const value = inlineValue ?? args[index + 1];
                 if (!value || value.startsWith('--')) throw new Error(`${arg} requires a value.`);
                 if ('--config' === arg) configPath = value;
                 else if ('--result-dir' === arg) resultDir = (0, external_node_path_.resolve)(cwd, value);
-                else projectNames.push(value);
+                else if ('--project' === arg) projectNames.push(value);
+                else {
+                    if ('default' !== value && 'verbose' !== value) throw new Error(`Unknown reporter: ${value}. Expected default or verbose.`);
+                    reporter = value;
+                }
                 if (void 0 === inlineValue) index += 1;
             } else throw new Error(`Unknown option: ${token}`);
         }
         if ('nodes' === command && resultDir) throw new Error('--result-dir is not supported by nodes.');
+        if ('nodes' === command && reporter) throw new Error('--reporter is not supported by nodes.');
         if ('nodes' === command && projectNames.length > 1) throw new Error('nodes accepts only one --project name.');
         return {
             ...command ? {
@@ -1884,13 +3416,27 @@ Each Node's returned \`data\` is saved on that Step's result. Results are not na
             resultDir,
             ...projectNames.length > 0 ? {
                 projectNames
+            } : {},
+            ...reporter ? {
+                reporter
             } : {}
         };
     };
     const defaultCliIO = {
         log: console.log,
         error: console.error,
-        write: (message)=>process.stdout.write(message)
+        write: process.stdout.write.bind(process.stdout),
+        isTTY: Boolean(process.stdout.isTTY && !process.env.CI),
+        get columns () {
+            return process.stdout.columns;
+        },
+        get rows () {
+            return process.stdout.rows;
+        },
+        onResize (listener) {
+            process.stdout.on('resize', listener);
+            return ()=>process.stdout.off('resize', listener);
+        }
     };
     const testCliHelp = `Midscene Test: run native cases/steps Test projects.
 
@@ -1905,6 +3451,7 @@ Options:
   --config <path>              Native TypeScript or JavaScript Test config
   --project <name>             Select a native execution Project (repeatable)
   --result-dir <path>          Store Test result files in this directory
+  --reporter <default|verbose> Concise Case results or full step diagnostics
   --help, -h                  Show this help
   --version                   Show the package version
 
@@ -1965,11 +3512,17 @@ Legacy tasks/flow YAML and its CLI options belong to the midscene command.
             io.log(`\nNode Spec generated: ${specPath}`);
         }
     };
-    const reportTestProjectResult = (result, io, infrastructureErrors = result.errors ?? [])=>{
+    const reportTestProjectResult = (result, io, reporter, projectRoot, infrastructureErrors = result.errors ?? [])=>{
+        reporter.finish(result);
         const reportedErrors = new Set();
-        const reportError = (source, error)=>{
+        const reportError = (source, error, sourcePath, context)=>{
             if (error instanceof Error && reportedErrors.has(error)) return;
-            io.error(`midscene-test: ${source}: ${formatCliError(error)}`);
+            reporter.failure(source, error, {
+                projectRoot,
+                ...context
+            });
+            const annotation = githubFailureAnnotation(source, formatConciseError(error), sourcePath ? (0, external_node_path_.resolve)(projectRoot, sourcePath) : void 0);
+            if (annotation) io.log(annotation);
             const pending = [
                 error
             ];
@@ -1981,7 +3534,33 @@ Legacy tasks/flow YAML and its CLI options belong to the midscene command.
                 if (current instanceof AggregateError) pending.push(...current.errors);
             }
         };
-        for (const failure of result.collectionErrors)reportError(`${failure.projectName}/${failure.sourcePath}`, failure.error);
+        for (const failure of result.collectionErrors)reportError(`${failure.projectName}/${failure.sourcePath}`, failure.error, failure.sourcePath, {
+            projectName: failure.projectName,
+            sourcePath: failure.sourcePath,
+            phase: 'collection'
+        });
+        const finalDocuments = new Map(result.documents.map((document)=>[
+                document.documentId,
+                document
+            ]));
+        const documentContext = (projectName, documentId, sourcePath)=>{
+            const project = result.projects.find((project)=>project.name === projectName);
+            const document = finalDocuments.get(documentId);
+            const plan = document?.plan ?? project?.plans?.find((plan)=>plan.documentId === documentId);
+            const fileIndex = document?.attemptIndex ?? 0;
+            return {
+                plan,
+                projectName,
+                sourcePath,
+                ...plan?.retry.scope === 'document' ? {
+                    fileAttempt: {
+                        index: fileIndex,
+                        total: Math.max(fileIndex + 1, plan.retry.count + 1)
+                    }
+                } : {},
+                caseAttempts: plan?.retry.scope === 'document' ? 1 : (plan?.retry.count ?? project?.retry ?? 0) + 1
+            };
+        };
         const finalCases = new Map(result.cases.map((outcome)=>[
                 outcome.caseId,
                 outcome
@@ -1990,43 +3569,101 @@ Legacy tasks/flow YAML and its CLI options belong to the midscene command.
             if ('failed' !== outcome.status || !outcome.run) continue;
             const run = outcome.run;
             const source = `${run.projectName}/${run.sourcePath} / ${run.name}`;
-            for (const step of [
-                ...run.beforeEach,
-                ...run.steps,
-                ...run.afterEach
-            ])if (step.error) reportError(`${source} / ${step.phase}[${step.stepIndex + 1}] ${step.node}`, step.error);
-            for (const error of [
-                ...run.executionErrors ?? [],
-                ...run.teardownErrors ?? []
-            ])reportError(source, error);
+            const { caseAttempts, plan, ...scope } = documentContext(run.projectName, outcome.documentId, run.sourcePath);
+            const context = {
+                ...scope,
+                caseName: run.name,
+                attempt: {
+                    index: run.attemptIndex,
+                    total: Math.max(caseAttempts, run.attemptIndex + 1)
+                }
+            };
+            const casePlan = plan?.cases.find((item)=>item.caseId === outcome.caseId);
+            for (const [phase, steps] of [
+                [
+                    'beforeEach',
+                    run.beforeEach
+                ],
+                [
+                    'steps',
+                    run.steps
+                ],
+                [
+                    'afterEach',
+                    run.afterEach
+                ]
+            ])for (const step of steps)if (step.error) reportError(`${source} / ${step.phase}[${step.stepIndex + 1}] ${step.node}${run.attemptIndex ? ` (failed after ${run.attemptIndex + 1} attempts)` : ''}`, step.error, run.sourcePath, {
+                ...context,
+                step,
+                stepCount: casePlan?.[phase].length
+            });
+            for (const [phase, errors] of [
+                [
+                    'execution',
+                    run.executionErrors
+                ],
+                [
+                    'teardown',
+                    run.teardownErrors
+                ]
+            ])for (const error of errors ?? [])reportError(source, error, run.sourcePath, {
+                ...context,
+                phase
+            });
         }
-        const finalDocuments = new Map(result.documents.map((document)=>[
-                document.documentId,
-                document
-            ]));
         for (const document of finalDocuments.values()){
             if ('failed' !== document.status) continue;
             const source = `${document.projectName}/${document.sourcePath}`;
-            for (const step of [
-                ...document.beforeAll,
-                ...document.afterAll
-            ])if (step.error) reportError(`${source} / ${step.phase}[${step.stepIndex + 1}] ${step.node}`, step.error);
-            for (const error of [
-                ...document.executionErrors ?? [],
-                ...document.teardownErrors ?? []
-            ])reportError(source, error);
-            for (const failure of document.hostErrors ?? [])reportError(`${source} / host ${failure.phase}`, failure.error);
+            const { caseAttempts: _, plan, ...context } = documentContext(document.projectName, document.documentId, document.sourcePath);
+            for (const [phase, steps] of [
+                [
+                    'beforeAll',
+                    document.beforeAll
+                ],
+                [
+                    'afterAll',
+                    document.afterAll
+                ]
+            ])for (const step of steps)if (step.error) reportError(`${source} / ${step.phase}[${step.stepIndex + 1}] ${step.node}`, step.error, document.sourcePath, {
+                ...context,
+                step,
+                stepCount: plan?.[phase].length
+            });
+            for (const [phase, errors] of [
+                [
+                    'execution',
+                    document.executionErrors
+                ],
+                [
+                    'teardown',
+                    document.teardownErrors
+                ]
+            ])for (const error of errors ?? [])reportError(source, error, document.sourcePath, {
+                ...context,
+                phase
+            });
+            for (const failure of document.hostErrors ?? [])reportError(`${source} / host ${failure.phase}`, failure.error, document.sourcePath, {
+                ...context,
+                phase: `host ${failure.phase}`
+            });
         }
         for (const project of result.projects){
-            if (project.lifecycle?.setupError) reportError(`${project.name} / setup`, project.lifecycle.setupError);
-            for (const error of project.lifecycle?.teardownErrors ?? [])reportError(`${project.name} / teardown`, error);
+            if (project.lifecycle?.setupError) reportError(`${project.name} / setup`, project.lifecycle.setupError, void 0, {
+                projectName: project.name,
+                phase: 'setup'
+            });
+            for (const error of project.lifecycle?.teardownErrors ?? [])reportError(`${project.name} / teardown`, error, void 0, {
+                projectName: project.name,
+                phase: 'teardown'
+            });
         }
         for (const error of infrastructureErrors)reportError('infrastructure', error);
-        io.log(`midscene-test: ${result.summary.passed}/${result.summary.total} cases passed, ${result.summary.failed} failed, ${result.summary.notRun} not run`);
-        io.log(`Results: ${result.resultDir}`);
+        reporter.summary(result);
+        if ('verbose' === reporter.mode) io.log(`Results: ${result.resultDir}`);
         io.log(`Summary: ${result.summaryPath}`);
-        if (result.markdownPath) io.log(`Markdown: ${result.markdownPath}`);
+        if (result.markdownPath && 'verbose' === reporter.mode) io.log(`Markdown: ${result.markdownPath}`);
         if (result.reportPath) io.log(`Report: ${result.reportPath}`);
+        writeGitHubSummary(result);
         return result.exitCode;
     };
     async function runTestCli(args, io = defaultCliIO) {
@@ -2056,18 +3693,32 @@ Legacy tasks/flow YAML and its CLI options belong to the midscene command.
                 await runNodesCommand(options, io);
                 return 0;
             }
-            let result;
+            const reporter = new TerminalReporter(io, options.reporter);
+            const restoreOutput = io === defaultCliIO && io.isTTY && 'verbose' !== options.reporter ? captureTerminalOutput((message, write)=>reporter.output(message, write)) : void 0;
+            const projectRoot = (0, external_node_fs_.realpathSync)(options.projectRoot && (0, external_node_fs_.existsSync)(options.projectRoot) && (0, external_node_fs_.statSync)(options.projectRoot).isFile() ? (0, external_node_path_.dirname)(options.projectRoot) : options.projectRoot ?? options.cwd);
             try {
-                result = await runTestProject({
-                    ...options,
-                    onProgress: (message)=>io.log(message)
+                return await (0, logger_namespaceObject.runWithConsoleLogHandler)((entry)=>reporter.console(entry), async ()=>{
+                    let result;
+                    try {
+                        result = await runTestProject({
+                            ...options,
+                            onProgress: (message)=>reporter.progress(message),
+                            onEvent: (event)=>reporter.event(event)
+                        });
+                    } catch (error) {
+                        if (!(error instanceof test_runner_namespaceObject.WorkflowExecutionFailure)) throw error;
+                        reportTestProjectResult(error.result, io, reporter, projectRoot, error.errors);
+                        return 1;
+                    }
+                    return reportTestProjectResult(result, io, reporter, projectRoot);
                 });
-            } catch (error) {
-                if (!(error instanceof test_runner_namespaceObject.WorkflowExecutionFailure)) throw error;
-                reportTestProjectResult(error.result, io, error.errors);
-                return 1;
+            } finally{
+                try {
+                    reporter.dispose();
+                } finally{
+                    restoreOutput?.();
+                }
             }
-            return reportTestProjectResult(result, io);
         } catch (error) {
             io.error(formatCliError(error));
             return 1;