@midscene/test 1.16.0 → 1.16.2

package/dist/es/test-cli.mjs

@@ -1,9 +1,13 @@
+import * as __rspack_external__midscene_shared_env_0c37bb76 from "@midscene/shared/env";
+import * as __rspack_external_chalk from "chalk";
 import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
 import * as __rspack_external_node_path_c5b9b54f from "node:path";
-import { NodeRegistry, WorkflowError, WorkflowExecutionFailure, WorkflowParseError, WorkflowPublicationError, asExecutionError, buildTestRunReportDump, buildTestRunReportPlan, classifyWorkflowDocumentFormat, collectTestRunReportSources, createProjectRuntime, decideRetry, isFatalDeviceError, isReportSecretKey, isResourceRecoveryError, normalizeSteps, observeResourceOperations, runConcurrentJobs, runDocumentAttempts, runWorkflowDocument, sanitizeReportError, sanitizeReportText } from "@midscene/core/internal/test-runner";
-import { inspect } from "node:util";
+import { NodeRegistry, WorkflowError, WorkflowExecutionFailure, WorkflowParseError, WorkflowPublicationError, asExecutionError, buildTestRunReportDump, buildTestRunReportPlan, classifyWorkflowDocumentFormat, collectTestRunReportSources, createProjectRuntime, decideRetry, getPendingScopeOperations, getResourceCleanupCompletion, isFatalDeviceError, isReportSecretKey, isResourceRecoveryError, normalizeSteps, observeResourceOperations, runDocumentAttempts, runWorkflowDocument, sanitizeReportError, sanitizeReportText, sanitizeReportValue, sumTestRunReportMetrics, trackResourceOperation, waitForScopeOperations } from "@midscene/core/internal/test-runner";
+import { getDebug, runWithConsoleLogHandler, runWithConsoleLogScope } from "@midscene/shared/logger";
+import { inspect, stripVTControlCharacters } from "node:util";
+import string_width from "string-width";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { z } from "zod/v4";
-import { pathToFileURL } from "node:url";
 import { require as api_require } from "tsx/cjs/api";
 import { globSync } from "tinyglobby";
 import { createHash, randomUUID } from "node:crypto";
@@ -11,8 +15,13 @@ import { JSON_SCHEMA, load } from "js-yaml";
 import { mkdir, writeFile } from "node:fs/promises";
 import { setMaxListeners } from "node:events";
 import { TestRunReportAssembler, calculateTestRunHealth } from "@midscene/core/report";
-import { getDebug } from "@midscene/shared/logger";
 var __webpack_modules__ = {
+    "@midscene/shared/env" (module) {
+        module.exports = __rspack_external__midscene_shared_env_0c37bb76;
+    },
+    chalk (module) {
+        module.exports = __rspack_external_chalk;
+    },
     "node:fs" (module) {
         module.exports = __rspack_external_node_fs_5ea92f0c;
     },
@@ -21,7 +30,7 @@ var __webpack_modules__ = {
     },
     "./package.json" (module) {
         module.exports = {
-            rE: "1.16.0"
+            rE: "1.16.2"
         };
     }
 };
@@ -102,6 +111,1017 @@ const formatCliError = (error)=>'string' == typeof error ? error : inspect(error
         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");
+const oneLine = (value)=>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 = 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 = sanitizeReportValue(input).value;
+    const render = (value)=>shorten(sanitizeReportError({
+            message: 'string' == typeof value ? value : 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 = sanitizeReportError({
+        message: formatConciseError(error)
+    }).message;
+    const lines = 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 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 = 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 (string_width(text) <= columns) return text;
+    let output = '';
+    let width = 0;
+    for (const { segment } of graphemes.segment(stripVTControlCharacters(text))){
+        width += string_width(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(string_width(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)=>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)=>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 - string_width(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 - string_width(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 GENERATED_COMMENT = '<!-- Generated by `midscene-test nodes`. Do not edit directly. -->';
 const sortNodesForSpec = (nodes)=>{
     const priority = (name)=>'aiAct' === name ? 0 : 'aiAssert' === name ? 1 : 2;
@@ -234,6 +1254,32 @@ const renderNodeSpec = (nodes, location)=>{
         warnings
     };
 };
+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 registry_NodeRegistry = NodeRegistry;
 const projectIdFromIndex = (index)=>`project-${index}`;
 const getDefaultExport = (loaded, absolutePath)=>{
@@ -352,9 +1398,19 @@ const validateNonNegativeInteger = (value, fallback, label)=>{
     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([
@@ -364,6 +1420,10 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
                     ...setup ? {
                         setup
                     } : {},
+                    ...fileSetup ? {
+                        fileSetup
+                    } : {},
+                    maxConcurrentFiles,
                     tags: Object.freeze({
                         include: [],
                         exclude: []
@@ -376,6 +1436,7 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         };
     }
     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)=>{
@@ -384,6 +1445,8 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         rejectUnknownKeys(candidate, [
             'name',
             'setup',
+            'fileSetup',
+            'maxConcurrentFiles',
             'nodes',
             'files',
             'tags',
@@ -400,10 +1463,18 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
             ...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
             } : {},
@@ -420,11 +1491,25 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         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')
     });
@@ -454,16 +1539,18 @@ const validateTestProjectDefinition = (definition)=>{
     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 registry_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)
@@ -540,11 +1627,13 @@ function parseWorkflowSource(source) {
                 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;
@@ -574,6 +1663,36 @@ function parseWorkflowSource(source) {
     const value = 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 ? {
@@ -632,7 +1751,7 @@ const resolveWorkflowVariables = (value, options)=>{
         ]));
     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,
@@ -649,7 +1768,7 @@ class NativeWorkflowFormatError extends WorkflowParseError {
             sourcePath,
             actualFormat,
             expectedFormat: 'native'
-        }), _define_property(this, "actualFormat", void 0);
+        }), collect_define_property(this, "actualFormat", void 0);
         this.actualFormat = actualFormat;
     }
 }
@@ -686,6 +1805,18 @@ function collectWorkflowDocument(source, options) {
     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,
@@ -860,6 +1991,9 @@ const writeTestProjectRunResult = (options)=>{
             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,
@@ -1137,7 +2271,24 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
             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) {
@@ -1239,11 +2390,12 @@ async function prepareTestRun(options) {
         preflightScope: hasFormatMismatch ? 'run' : 'project',
         reportEnabled: true,
         publications: [],
-        onProgress: options.onProgress ?? (()=>{})
+        onProgress: options.onProgress ?? (()=>{}),
+        onEvent: options.onEvent
     };
 }
 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`;
 };
@@ -1254,7 +2406,7 @@ function renderTestResultMarkdown(dump, options = {}) {
     const lines = [
         '## Midscene Test',
         '',
-        `${outcome} · ${duration(dump.durationMs)}`,
+        `${outcome} · ${result_markdown_duration(dump.durationMs)}`,
         ''
     ];
     if (summary.filtered) lines.push(`**Filtered:** ${summary.filtered}`, '');
@@ -1317,6 +2469,38 @@ async function writeTestResultMarkdown(result, index = emptyIndex()) {
     }));
     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 runWithConsoleLogScope(scope, ()=>node.execute({
+                    ...ctx,
+                    onTeardown (teardown) {
+                        ctx.onTeardown(()=>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);
@@ -1340,59 +2524,149 @@ const documentHasFatalError = (result)=>[
         ...result.beforeAll,
         ...result.afterAll
     ].some((step)=>step.error && isFatalDeviceError(step.error)) || (result.teardownErrors ?? []).some(isFatalDeviceError) || !!result.executionErrors?.some(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 runWithConsoleLogScope(scope, async ()=>{
+                try {
+                    return await fileSetup.setup({
+                        ...ctx,
+                        onTeardown (teardown) {
+                            ctx.onTeardown(()=>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 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 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 && isFatalDeviceError(step.error)) || (run.teardownErrors ?? []).some(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 runWithConsoleLogScope({
+            projectName: project.name,
+            sourcePath: document.sourcePath
+        }, ()=>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 && (isFatalDeviceError(step.error) || isProjectResourceFailure(step.error))) || (run.teardownErrors ?? []).some((error)=>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 WorkflowExecutionFailure) {
                 const partial = error.result;
                 const resourceOnly = error.errors.length > 0 && error.errors.every((failure)=>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(isResourceRecoveryError)) options.markProjectFatal();
+                    if (!options.isolatedContext && error.errors.some(isResourceRecoveryError)) options.markProjectFatal();
                     return partial;
                 }
                 if (documentRetry) partial.document.retryDecision = decideRetry({
@@ -1421,7 +2695,17 @@ async function executeDocumentInvocation(options) {
             }
             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 ?? [])
@@ -1429,7 +2713,10 @@ async function executeDocumentInvocation(options) {
         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 = decideRetry({
             scope: 'document',
@@ -1444,6 +2731,11 @@ async function executeDocumentInvocation(options) {
             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,
@@ -1478,10 +2770,280 @@ async function executeDocumentInvocation(options) {
     });
     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 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 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([
+                waitForScopeOperations(state.runtime.signal),
+                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 = createProjectRuntime({
+                    project,
+                    setup: project.setup,
+                    signal: options.signal,
+                    setupTimeoutMs: options.setupTimeoutMs,
+                    teardownTimeoutMs: options.teardownTimeoutMs
+                });
+                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 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 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 && 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')) 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);
+        });
+        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,
+                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, '', {
@@ -1550,8 +3112,34 @@ async function runPreparedTestProject(plan) {
     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();
@@ -1565,6 +3153,18 @@ async function runPreparedTestProject(plan) {
     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)=>{
@@ -1626,112 +3226,30 @@ async function runPreparedTestProject(plan) {
         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 = 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 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 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);
@@ -1808,6 +3326,10 @@ async function runPreparedTestProject(plan) {
                 buildRunnerDump: (index)=>{
                     reportIndex = index;
                     const dump = buildTestRunReportDump(completedResult, index);
+                    completedResult = {
+                        ...completedResult,
+                        metrics: dump.metrics
+                    };
                     const warn = getDebug('test-runner:report-assembler', {
                         console: true
                     });
@@ -1825,6 +3347,16 @@ async function runPreparedTestProject(plan) {
         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 = buildTestRunReportDump(completedResult, reportIndex ?? {
+                sources: [],
+                metrics: sumTestRunReportMetrics([])
+            });
+            completedResult = {
+                ...completedResult,
+                metrics: dump.metrics
+            };
+        }
         const markdownPath = await writeTestResultMarkdown(completedResult, reportIndex);
         completedResult = {
             ...completedResult,
@@ -1845,6 +3377,7 @@ const parseTestCliArgs = (args, cwd = process.cwd())=>{
     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;
@@ -1855,16 +3388,21 @@ const parseTestCliArgs = (args, cwd = process.cwd())=>{
             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 ? {
@@ -1876,13 +3414,27 @@ const parseTestCliArgs = (args, cwd = process.cwd())=>{
         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.
 
@@ -1897,6 +3449,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
 
@@ -1957,11 +3510,17 @@ const runNodesCommand = async (options, io)=>{
         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
         ];
@@ -1973,7 +3532,33 @@ const reportTestProjectResult = (result, io, infrastructureErrors = result.error
             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
@@ -1982,49 +3567,107 @@ const reportTestProjectResult = (result, io, infrastructureErrors = result.error
         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) {
     try {
         if ('model' === args[0]) {
-            const { runModelCommand } = await __webpack_require__.e("77").then(__webpack_require__.bind(__webpack_require__, "./src/cli/model-command.ts?bb10"));
+            const { runModelCommand } = await __webpack_require__.e("731").then(__webpack_require__.bind(__webpack_require__, "./src/cli/model-command.ts?3cff"));
             return runModelCommand(args, void 0, {
                 stdout: io.log,
                 stderr: io.error
@@ -2048,18 +3691,32 @@ async function runTestCli(args, io = defaultCliIO) {
             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 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 WorkflowExecutionFailure)) throw error;
+                    reportTestProjectResult(error.result, io, reporter, projectRoot, error.errors);
+                    return 1;
+                }
+                return reportTestProjectResult(result, io, reporter, projectRoot);
             });
-        } catch (error) {
-            if (!(error instanceof 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;