@midscene/test 1.12.10-beta-20260920031616.0 → 1.13.0

package/dist/es/cli/index.mjs

@@ -2,283 +2,16 @@ import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { pathToFileURL } from "node:url";
 import { require as api_require } from "tsx/cjs/api";
 import { tsImport } from "tsx/esm/api";
-import { z } from "zod/v4";
+import { NodeRegistry, WorkflowError, WorkflowExecutionFailure, WorkflowParseError, WorkflowPublicationError, asExecutionError, buildTestRunReportDump, classifyWorkflowDocumentFormat, collectTestRunReportSources, createProjectRuntime, isFatalDeviceError, normalizeSteps, runConcurrentJobs, runDocumentAttempts, runWorkflowDocument } from "@midscene/core/internal/test-runner";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { globSync } from "tinyglobby";
+import { JSON_SCHEMA, load } from "js-yaml";
 import { createHash, randomUUID } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
 import { setMaxListeners } from "node:events";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
 import { TestRunReportAssembler } from "@midscene/core/report";
-import { globSync } from "tinyglobby";
-import { JSON_SCHEMA, load } from "js-yaml";
 import { getDebug } from "@midscene/shared/logger";
-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;
-}
-class WorkflowError extends Error {
-    toJSON() {
-        return {
-            name: this.name,
-            message: this.message,
-            code: this.code,
-            ...void 0 === this.details ? {} : {
-                details: this.details
-            }
-        };
-    }
-    constructor(message, options = {}){
-        super(message, {
-            cause: options.cause
-        }), _define_property(this, "code", void 0), _define_property(this, "details", void 0);
-        this.name = new.target.name;
-        this.code = options.code ?? 'WORKFLOW_ERROR';
-        this.details = options.details;
-    }
-}
-class WorkflowParseError extends WorkflowError {
-    constructor(message, details, cause){
-        super(message, {
-            code: 'WORKFLOW_PARSE_ERROR',
-            details,
-            cause
-        });
-    }
-}
-class NodeDefinitionError extends WorkflowError {
-    constructor(message, details){
-        super(message, {
-            code: 'NODE_DEFINITION_ERROR',
-            details
-        });
-    }
-}
-class DuplicateNodeError extends WorkflowError {
-    constructor(node){
-        super(`Node "${node}" is already registered.`, {
-            code: 'DUPLICATE_NODE',
-            details: {
-                node
-            }
-        }), _define_property(this, "node", void 0);
-        this.node = node;
-    }
-}
-class NodeNotFoundError extends WorkflowError {
-    constructor(node){
-        super(`Node "${node}" is not registered.`, {
-            code: 'NODE_NOT_FOUND',
-            details: {
-                node
-            }
-        }), _define_property(this, "node", void 0);
-        this.node = node;
-    }
-}
-class NodeInputValidationError extends WorkflowError {
-    static fromZod(node, error) {
-        const issues = error.issues.map((issue)=>({
-                code: issue.code,
-                path: issue.path.map(String).join('.'),
-                message: issue.message
-            }));
-        const firstIssue = issues[0];
-        const path = firstIssue?.path || '<root>';
-        const message = firstIssue?.message ?? 'invalid input';
-        return new NodeInputValidationError(`Node "${node}" input validation failed at "${path}": ${message}`, {
-            node,
-            issues
-        });
-    }
-    constructor(message, details){
-        super(message, {
-            code: 'NODE_INPUT_VALIDATION_ERROR',
-            details
-        });
-    }
-}
-class StepTimeoutError extends WorkflowError {
-    constructor(timeoutMs, node){
-        super(node ? `Node "${node}" timed out after ${timeoutMs}ms.` : `Step timed out after ${timeoutMs}ms.`, {
-            code: 'STEP_TIMEOUT',
-            details: {
-                timeoutMs,
-                ...void 0 === node ? {} : {
-                    node
-                }
-            }
-        }), _define_property(this, "timeoutMs", void 0), _define_property(this, "node", void 0);
-        this.timeoutMs = timeoutMs;
-        this.node = node;
-    }
-}
-class NodeExecutionError extends WorkflowError {
-    constructor(node, cause){
-        const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-        super(`Node "${node}" failed: ${causeMessage}`, {
-            code: 'NODE_EXECUTION_ERROR',
-            details: {
-                node
-            },
-            cause
-        }), _define_property(this, "node", void 0);
-        this.node = node;
-    }
-}
-class WorkflowLifecycleError extends WorkflowError {
-    constructor(message, details){
-        super(message, {
-            code: 'WORKFLOW_LIFECYCLE_ERROR',
-            details
-        });
-    }
-}
-class ProjectSetupError extends WorkflowError {
-    constructor(cause, details){
-        const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-        super(`Project "${details.projectName}" setup failed: ${causeMessage}`, {
-            code: 'PROJECT_SETUP_ERROR',
-            details,
-            cause
-        });
-    }
-}
-class ProjectTeardownError extends WorkflowError {
-    constructor(cause, details){
-        const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-        super(`Project "${details.projectName}" teardown failed: ${causeMessage}`, {
-            code: 'PROJECT_TEARDOWN_ERROR',
-            details,
-            cause
-        });
-    }
-}
-class NodeScopeTeardownError extends WorkflowError {
-    constructor(cause, details){
-        const causeMessage = cause instanceof Error ? cause.message : String(cause ?? 'Unknown error');
-        super(`${'case' === details.scope ? 'Case attempt' : 'Workflow document'} node teardown failed for "${details.node}": ${causeMessage}`, {
-            code: 'NODE_SCOPE_TEARDOWN_ERROR',
-            details,
-            cause
-        });
-    }
-}
-class FatalDeviceError extends WorkflowError {
-    constructor(message, cause){
-        super(message, {
-            code: 'FATAL_DEVICE_ERROR',
-            cause
-        });
-    }
-}
-const isFatalDeviceError = (error)=>{
-    if (error instanceof FatalDeviceError) return true;
-    if (error instanceof WorkflowError && 'FATAL_DEVICE_ERROR' === error.code) return true;
-    if (error instanceof Error && /device offline|device not found|(?:adb|bdc|device) connection (?:was )?closed/i.test(error.message)) return true;
-    return error instanceof Error && void 0 !== error.cause ? isFatalDeviceError(error.cause) : false;
-};
-function normalizeNodeExecutionError(error, node) {
-    return error instanceof WorkflowError ? error : new NodeExecutionError(node, error);
-}
-const validateOptionalText = (value, field, node)=>{
-    if (void 0 !== value && ('string' != typeof value || 0 === value.trim().length)) throw new NodeDefinitionError(`Node "${node}" ${field} must be a non-empty string.`, {
-        node,
-        field
-    });
-};
-const validateInputSchema = (schema, node)=>{
-    if (void 0 === schema) return;
-    if (!(schema instanceof z.ZodObject)) throw new NodeDefinitionError(`Node "${node}" inputSchema must be a Zod object schema.`, {
-        node,
-        field: 'inputSchema'
-    });
-    if ('$' in schema.shape) throw new NodeDefinitionError(`Node "${node}" inputSchema must not declare "$" as an input property.`, {
-        node,
-        field: 'inputSchema.$'
-    });
-};
-const validateDefinition = (options)=>{
-    if (!options || 'object' != typeof options) throw new NodeDefinitionError('Node definition must be an object.');
-    if ('string' != typeof options.name || 0 === options.name.trim().length) throw new NodeDefinitionError('Node name must be a non-empty string.');
-    validateOptionalText(options.title, 'title', options.name);
-    validateOptionalText(options.description, "description", options.name);
-    if (void 0 !== options.stringInputKey && false !== options.stringInputKey && ('string' != typeof options.stringInputKey || 0 === options.stringInputKey.trim().length)) throw new NodeDefinitionError(`Node "${options.name}" stringInputKey must be a non-empty string or false.`, {
-        node: options.name,
-        field: 'stringInputKey'
-    });
-    validateInputSchema(options.inputSchema, options.name);
-    if ('string' == typeof options.stringInputKey && options.inputSchema instanceof z.ZodObject && !(options.stringInputKey in options.inputSchema.shape)) throw new NodeDefinitionError(`Node "${options.name}" stringInputKey must reference a field in inputSchema.`, {
-        node: options.name,
-        field: 'stringInputKey'
-    });
-    if ('function' != typeof options.execute) throw new NodeDefinitionError(`Node "${options.name}" must provide an execute function.`, {
-        node: options.name
-    });
-};
-function defineNode(options) {
-    validateDefinition(options);
-    return options;
-}
-function _check_private_redeclaration(obj, privateCollection) {
-    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
-}
-function _class_apply_descriptor_get(receiver, descriptor) {
-    if (descriptor.get) return descriptor.get.call(receiver);
-    return descriptor.value;
-}
-function _class_extract_field_descriptor(receiver, privateMap, action) {
-    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
-    return privateMap.get(receiver);
-}
-function _class_private_field_get(receiver, privateMap) {
-    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
-    return _class_apply_descriptor_get(receiver, descriptor);
-}
-function _class_private_field_init(obj, privateMap, value) {
-    _check_private_redeclaration(obj, privateMap);
-    privateMap.set(obj, value);
-}
-var _nodes = /*#__PURE__*/ new WeakMap();
-class NodeRegistry {
-    register(node) {
-        defineNode(node);
-        if (_class_private_field_get(this, _nodes).has(node.name)) throw new DuplicateNodeError(node.name);
-        _class_private_field_get(this, _nodes).set(node.name, node);
-        return this;
-    }
-    get(name) {
-        return _class_private_field_get(this, _nodes).get(name);
-    }
-    require(name) {
-        const node = this.get(name);
-        if (!node) throw new NodeNotFoundError(name);
-        return node;
-    }
-    has(name) {
-        return _class_private_field_get(this, _nodes).has(name);
-    }
-    names() {
-        return [
-            ..._class_private_field_get(this, _nodes).keys()
-        ];
-    }
-    definitions() {
-        return [
-            ..._class_private_field_get(this, _nodes).values()
-        ];
-    }
-    constructor(nodes = []){
-        _class_private_field_init(this, _nodes, {
-            writable: true,
-            value: new Map()
-        });
-        for (const node of nodes)this.register(node);
-    }
-}
+const registry_NodeRegistry = NodeRegistry;
 const projectIdFromIndex = (index)=>`project-${index}`;
 const defineTestProject = (definition)=>definition;
 const defineProjectSetup = (definition)=>definition;
@@ -318,6 +51,10 @@ const validatePatterns = (value, field, label = 'files', allowEmptyInclude = fal
 const validateTestFileSelection = (value, label = 'files')=>{
     if (void 0 === value) return;
     if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
+    rejectUnknownKeys(value, [
+        'include',
+        'exclude'
+    ], label);
     const include = validatePatterns(value.include, 'include', label);
     const exclude = void 0 === value.exclude ? void 0 : validatePatterns(value.exclude, 'exclude', label);
     return Object.freeze({
@@ -373,7 +110,7 @@ const validateVariables = (value, label)=>{
     assertJsonValue(value, label, new Set());
     return deepFreezeJson(value);
 };
-const validateProjectSetup = (value, label)=>{
+const validateSetup = (value, label)=>{
     if (void 0 === value) return;
     if (!isRecord(value)) throw new TypeError(`Midscene config ${label} must be an object.`);
     rejectUnknownKeys(value, [
@@ -396,7 +133,7 @@ const validateNonNegativeInteger = (value, fallback, label)=>{
 };
 const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
     if (void 0 === value) {
-        const setup = validateProjectSetup(defaultSetup, 'setup');
+        const setup = validateSetup(defaultSetup, 'setup');
         return {
             hasExplicitProjects: false,
             projects: Object.freeze([
@@ -412,7 +149,7 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
                     }),
                     retry: 0,
                     variables: Object.freeze({}),
-                    nodes: new NodeRegistry(globalNodes.definitions())
+                    nodes: new registry_NodeRegistry(globalNodes.definitions())
                 })
             ])
         };
@@ -437,8 +174,8 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
         names.add(candidate.name);
         const files = validateTestFileSelection(candidate.files, `${label}.files`);
         if (void 0 !== candidate.nodes && !Array.isArray(candidate.nodes)) throw new TypeError(`Midscene config ${label}.nodes must be an array.`);
-        const localNodes = new NodeRegistry(candidate.nodes);
-        const nodes = new NodeRegistry([
+        const localNodes = new registry_NodeRegistry(candidate.nodes);
+        const nodes = new registry_NodeRegistry([
             ...globalNodes.definitions().filter((node)=>!localNodes.has(node.name)),
             ...localNodes.definitions()
         ]);
@@ -453,7 +190,7 @@ const validateExecutionProjects = (value, defaultSetup, globalNodes)=>{
             retry: validateNonNegativeInteger(candidate.retry, 0, `${label}.retry`),
             variables: validateVariables(candidate.variables, `${label}.variables`),
             ...void 0 === candidate.setup ? {} : {
-                setup: validateProjectSetup(candidate.setup, `${label}.setup`)
+                setup: validateSetup(candidate.setup, `${label}.setup`)
             }
         });
     });
@@ -501,7 +238,7 @@ const validateTestProjectDefinition = (definition)=>{
         'output',
         'nodes'
     ], 'root');
-    const nodes = new NodeRegistry(definition.nodes);
+    const nodes = new registry_NodeRegistry(definition.nodes);
     const resolvedProjects = validateExecutionProjects(definition.projects, definition.setup, nodes);
     return {
         ...resolvedProjects,
@@ -548,761 +285,22 @@ async function loadTestProject(configPath) {
     }
     return validateTestProjectDefinition(getDefaultExport(loaded, absolutePath));
 }
-const createProjectRuntime = (options)=>{
-    const startedAt = new Date();
-    const controller = new AbortController();
-    const parentSignal = options.signal;
-    const abortFromParent = ()=>controller.abort(parentSignal?.reason);
-    if (parentSignal?.aborted) abortFromParent();
-    else parentSignal?.addEventListener('abort', abortFromParent, {
-        once: true
-    });
-    const teardownStack = [];
-    let context;
-    let setupError;
-    let started = false;
-    let acceptingTeardowns = void 0 !== options.setup;
-    let finishedResult;
-    const createResult = (requestedStatus, teardownErrors = [])=>{
-        const endedAt = new Date();
-        return {
-            projectName: options.project.name,
-            status: 'failed' === requestedStatus || setupError || teardownErrors.length > 0 ? 'failed' : 'success',
-            ...setupError ? {
-                setupError
-            } : {},
-            ...teardownErrors.length > 0 ? {
-                teardownErrors
-            } : {},
-            startedAt: startedAt.toISOString(),
-            endedAt: endedAt.toISOString(),
-            durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
-        };
-    };
-    const onTeardown = (teardown)=>{
-        if (!acceptingTeardowns) throw new WorkflowLifecycleError('onTeardown() can only be called while Project setup is running.', {
-            projectName: options.project.name
-        });
-        if ('function' != typeof teardown) throw new WorkflowLifecycleError('Project onTeardown() requires a teardown function.', {
-            projectName: options.project.name
-        });
-        teardownStack.push({
-            registrationIndex: teardownStack.length,
-            teardown
-        });
-    };
-    return {
-        get context () {
-            return context;
-        },
-        get signal () {
-            return controller.signal;
-        },
-        get canRun () {
-            return started && !setupError && !controller.signal.aborted;
-        },
-        async start () {
-            if (started) throw new WorkflowLifecycleError('Project runtime has already started.', {
-                projectName: options.project.name
-            });
-            started = true;
-            if (controller.signal.aborted) {
-                acceptingTeardowns = false;
-                return createResult('failed');
-            }
-            if (options.setup) try {
-                context = await options.setup.setup({
-                    project: options.project,
-                    env: Object.freeze({
-                        ...process.env
-                    }),
-                    signal: controller.signal,
-                    onTeardown
-                });
-            } catch (error) {
-                setupError = new ProjectSetupError(error, {
-                    projectName: options.project.name
-                });
-            } finally{
-                acceptingTeardowns = false;
-            }
-            return createResult(setupError ? 'failed' : 'success');
-        },
-        async finish (requestedStatus = 'success') {
-            if (finishedResult) return finishedResult;
-            if (!started) throw new WorkflowLifecycleError('Project runtime must start before it can finish.', {
-                projectName: options.project.name
-            });
-            const statusBeforeTeardown = createResult(requestedStatus).status;
-            const teardownErrors = [];
-            for (const { registrationIndex, teardown } of teardownStack.reverse())try {
-                await teardown({
-                    project: options.project,
-                    context,
-                    status: statusBeforeTeardown,
-                    ...setupError ? {
-                        setupError
-                    } : {}
-                });
-            } catch (error) {
-                teardownErrors.push(new ProjectTeardownError(error, {
-                    projectName: options.project.name,
-                    registrationIndex
-                }));
-            }
-            parentSignal?.removeEventListener('abort', abortFromParent);
-            finishedResult = createResult(requestedStatus, teardownErrors);
-            return finishedResult;
-        },
-        abort (reason) {
-            controller.abort(reason);
-        }
-    };
-};
-const assertJsonSerializable = (value, label, node)=>{
-    const visit = (candidate, path, seen)=>{
-        if (null === candidate || 'string' == typeof candidate || 'boolean' == typeof candidate) return;
-        if ('number' == typeof candidate) {
-            if (Number.isFinite(candidate)) return;
-            throw new TypeError(`${path} contains a non-finite number.`);
-        }
-        if (void 0 === candidate) throw new TypeError(`${path} contains undefined.`);
-        if ('object' != typeof candidate) throw new TypeError(`${path} is not JSON-serializable.`);
-        if (!Array.isArray(candidate) && Object.getPrototypeOf(candidate) !== Object.prototype && null !== Object.getPrototypeOf(candidate)) throw new TypeError(`${path} must contain only plain objects.`);
-        if (seen.has(candidate)) throw new TypeError(`${path} contains a cycle.`);
-        seen.add(candidate);
-        if (Array.isArray(candidate)) candidate.forEach((child, index)=>visit(child, `${path}[${index}]`, seen));
-        else for (const [key, child] of Object.entries(candidate))visit(child, `${path}.${key}`, seen);
-        seen.delete(candidate);
-    };
-    try {
-        visit(value, label, new Set());
-    } catch (error) {
-        throw new NodeExecutionError(node, error);
-    }
-};
-function validateNodeOutput(output, node) {
-    if (void 0 === output) return;
-    if ('object' != typeof output || null === output || Array.isArray(output)) throw new NodeExecutionError(node, new TypeError('Node output must be an object or undefined.'));
-    if ('summary' in output && void 0 !== output.summary && 'string' != typeof output.summary) throw new NodeExecutionError(node, new TypeError('Node output summary must be a string.'));
-    if ('data' in output && void 0 !== output.data) assertJsonSerializable(output.data, 'output.data', node);
-    return output;
-}
-function createStepResultBase(step, startedAt, phase, stepIndex) {
-    const endedAt = new Date();
-    return {
-        node: step.node,
-        phase,
-        stepIndex,
-        input: step.input,
-        meta: step.meta,
-        startedAt: startedAt.toISOString(),
-        endedAt: endedAt.toISOString(),
-        durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
-    };
-}
-async function executeNode(step, execute, phase, stepIndex, options) {
-    const startedAt = new Date();
-    const abortController = new AbortController();
-    const parentSignal = options.parentSignal;
-    const abortFromParent = ()=>abortController.abort(parentSignal?.reason);
-    if (parentSignal?.aborted) abortFromParent();
-    else parentSignal?.addEventListener('abort', abortFromParent, {
-        once: true
-    });
-    const timeoutMs = step.meta.timeoutMs ?? options.defaultTimeoutMs;
-    let timeout;
-    let abortGraceTimeout;
-    const execution = Promise.resolve().then(()=>{
-        abortController.signal.throwIfAborted();
-        return execute(abortController.signal);
-    });
-    let settleOnAbort;
-    const abortedExecution = new Promise((_, reject)=>{
-        settleOnAbort = ()=>{
-            abortGraceTimeout = setTimeout(()=>{
-                reject(abortController.signal.reason);
-            }, 0);
-        };
-        if (abortController.signal.aborted) settleOnAbort();
-        else abortController.signal.addEventListener('abort', settleOnAbort, {
-            once: true
-        });
-    });
-    const timeoutExecution = void 0 === timeoutMs ? void 0 : new Promise((_, reject)=>{
-        timeout = setTimeout(()=>{
-            if (abortController.signal.aborted) return void reject(abortController.signal.reason);
-            const timeoutError = new StepTimeoutError(timeoutMs, step.node);
-            abortController.abort(timeoutError);
-            reject(timeoutError);
-        }, timeoutMs);
-    });
-    const settledExecution = Promise.race([
-        execution,
-        abortedExecution,
-        ...void 0 === timeoutExecution ? [] : [
-            timeoutExecution
-        ]
-    ]);
-    try {
-        const output = validateNodeOutput(await settledExecution, step.node);
-        return {
-            ...createStepResultBase(step, startedAt, phase, stepIndex),
-            status: 'success',
-            continuedAfterError: false,
-            ...void 0 === output ? {} : {
-                output
-            }
-        };
-    } catch (error) {
-        return {
-            ...createStepResultBase(step, startedAt, phase, stepIndex),
-            status: 'failed',
-            continuedAfterError: step.meta.continueOnError,
-            error: normalizeNodeExecutionError(error, step.node)
-        };
-    } finally{
-        if (void 0 !== timeout) clearTimeout(timeout);
-        if (void 0 !== abortGraceTimeout) clearTimeout(abortGraceTimeout);
-        if (void 0 !== settleOnAbort) abortController.signal.removeEventListener('abort', settleOnAbort);
-        parentSignal?.removeEventListener('abort', abortFromParent);
-    }
-}
-function createNodeReportCollector(node) {
-    const traces = new Map();
-    let accepting = true;
-    return {
-        collector: Object.freeze({
-            addTrace (trace) {
-                if (!accepting) throw new NodeExecutionError(node, new Error('Report traces can only be added while the current Step is running.'));
-                if (!trace || 'object' != typeof trace || 'midscene-execution' !== trace.type) throw new NodeExecutionError(node, new TypeError('Report trace type must be "midscene-execution".'));
-                if ('string' != typeof trace.executionId || 0 === trace.executionId.trim().length) throw new NodeExecutionError(node, new TypeError('Report trace executionId must be non-empty.'));
-                const normalized = Object.freeze({
-                    type: 'midscene-execution',
-                    executionId: trace.executionId
-                });
-                traces.set(`${normalized.type}:${normalized.executionId}`, normalized);
-            }
-        }),
-        close () {
-            accepting = false;
-            return Object.freeze([
-                ...traces.values()
-            ]);
-        }
-    };
-}
-async function parseNodeInput(node, input) {
-    if (!node.inputSchema) return input;
-    const parsed = await node.inputSchema.safeParseAsync(input);
-    if (!parsed.success) throw NodeInputValidationError.fromZod(node.name, parsed.error);
-    return parsed.data;
-}
-async function executeStep(step, node, target, context, execution = {}) {
-    const phase = 'case' === target.scope ? target.case.phase : target.document.phase;
-    const stepIndex = 'case' === target.scope ? target.case.stepIndex : target.document.stepIndex;
-    const reportCollector = createNodeReportCollector(step.node);
-    let result;
-    try {
-        result = await executeNode(step, async (signal)=>{
-            const input = await parseNodeInput(node, step.input);
-            signal.throwIfAborted();
-            const common = {
-                input,
-                $: step.meta,
-                signal,
-                context,
-                report: reportCollector.collector,
-                onTeardown: (teardown)=>{
-                    if (!execution.onTeardown) throw new NodeExecutionError(step.node, new Error('The current execution scope cannot register teardown.'));
-                    execution.onTeardown(step.node, teardown);
-                }
-            };
-            return 'case' === target.scope ? node.execute({
-                ...common,
-                scope: 'case',
-                case: target.case
-            }) : node.execute({
-                ...common,
-                scope: 'document',
-                document: target.document
-            });
-        }, phase, stepIndex, {
-            parentSignal: execution.signal,
-            defaultTimeoutMs: execution.defaultTimeoutMs
-        });
-    } finally{
-        const traces = reportCollector.close();
-        if (traces.length > 0 && result) result = {
-            ...result,
-            report: {
-                traces
-            }
-        };
-    }
-    if (!result) throw new NodeExecutionError(step.node, new Error('Step execution completed without a result.'));
-    return result;
-}
-const reportPathsFromTeardown = (result)=>{
-    if (void 0 === result) return [];
-    if ('object' != typeof result || null === result || Array.isArray(result)) throw new TypeError('Node teardown result must be an object or undefined.');
-    const paths = result.reportPaths;
-    if (void 0 === paths) return [];
-    if (!Array.isArray(paths)) throw new TypeError('Node teardown reportPaths must be an array.');
-    return paths.map((path, index)=>{
-        if ('string' != typeof path || 0 === path.trim().length) throw new TypeError(`Node teardown reportPaths[${index}] must be a non-empty string.`);
-        if (!isAbsolute(path)) throw new TypeError(`Node teardown reportPaths[${index}] must be an absolute path.`);
-        return path;
-    });
-};
-function createDocumentRuntime(document, options) {
-    const documentRunId = options.createDocumentRunId?.() ?? randomUUID();
-    const startedAt = new Date();
-    const beforeAll = [];
-    const afterAll = [];
-    const nodes = {
-        beforeAll: document.lifecycle.beforeAll.map((step)=>options.resolveNode(step.node)),
-        afterAll: document.lifecycle.afterAll.map((step)=>options.resolveNode(step.node))
-    };
-    const project = options.project ?? Object.freeze({
-        projectId: document.projectId,
-        name: document.projectId,
-        tags: Object.freeze({
-            include: [],
-            exclude: []
-        }),
-        retry: 0,
-        variables: Object.freeze({})
-    });
-    const context = options.projectContext;
-    const signal = options.signal ?? new AbortController().signal;
-    const nodeTeardownStack = [];
-    let acceptingNodeTeardowns = true;
-    let started = false;
-    let finishedResult;
-    const reportPaths = new Set();
-    const createResult = (teardownErrors = [])=>{
-        const endedAt = new Date();
-        return {
-            documentId: document.documentId,
-            documentRunId,
-            projectId: document.projectId,
-            projectName: project.name,
-            sourcePath: document.sourcePath,
-            status: beforeAll.some((step)=>'failed' === step.status) || afterAll.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
-            startedAt: startedAt.toISOString(),
-            endedAt: endedAt.toISOString(),
-            durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),
-            beforeAll: [
-                ...beforeAll
-            ],
-            afterAll: [
-                ...afterAll
-            ],
-            ...teardownErrors.length > 0 ? {
-                teardownErrors
-            } : {},
-            ...reportPaths.size > 0 ? {
-                reportPaths: [
-                    ...reportPaths
-                ]
-            } : {}
-        };
-    };
-    const runPhase = async (phase, results, executionSignal = signal)=>{
-        for (const [stepIndex, step] of document.lifecycle[phase].entries()){
-            const documentContext = {
-                documentId: document.documentId,
-                documentRunId,
-                projectId: document.projectId,
-                projectName: project.name,
-                sourcePath: document.sourcePath,
-                phase,
-                stepIndex
-            };
-            const stepInfo = {
-                scope: 'document',
-                node: step.node,
-                stepCount: document.lifecycle[phase].length,
-                document: documentContext
-            };
-            await options.onStepStart?.(stepInfo);
-            const result = await executeStep(step, nodes[phase][stepIndex], {
-                scope: 'document',
-                document: documentContext
-            }, context, {
-                signal: executionSignal,
-                defaultTimeoutMs: options.defaultTimeoutMs,
-                onTeardown (node, teardown) {
-                    if (!acceptingNodeTeardowns) throw new WorkflowLifecycleError('Node teardown can only be registered while a workflow document is running.', {
-                        documentId: document.documentId,
-                        documentRunId,
-                        node
-                    });
-                    if ('function' != typeof teardown) throw new WorkflowLifecycleError('Node onTeardown() requires a teardown function.', {
-                        documentId: document.documentId,
-                        documentRunId,
-                        node
-                    });
-                    nodeTeardownStack.push({
-                        registrationIndex: nodeTeardownStack.length,
-                        node,
-                        teardown
-                    });
-                }
-            });
-            await options.onStepResult?.(stepInfo, result);
-            results.push(result);
-            if ('failed' === result.status && !result.continuedAfterError) break;
-        }
-    };
-    return {
-        get context () {
-            return context;
-        },
-        get canRunCases () {
-            return started && !signal.aborted && !beforeAll.some((step)=>'failed' === step.status);
-        },
-        async start () {
-            if (started) throw new WorkflowLifecycleError('Workflow document runtime has already started.', {
-                documentId: document.documentId,
-                documentRunId
-            });
-            started = true;
-            if (!signal.aborted) await runPhase('beforeAll', beforeAll);
-            return createResult();
-        },
-        async finish () {
-            if (finishedResult) return finishedResult;
-            if (!started) throw new WorkflowLifecycleError('Workflow document runtime must start before it can finish.', {
-                documentId: document.documentId,
-                documentRunId
-            });
-            let finishError;
-            try {
-                await runPhase('afterAll', afterAll, signal.aborted ? new AbortController().signal : signal);
-            } catch (error) {
-                finishError = error;
-            }
-            acceptingNodeTeardowns = false;
-            const teardownErrors = [];
-            for (const { registrationIndex, node, teardown } of nodeTeardownStack.reverse())try {
-                for (const path of reportPathsFromTeardown(await teardown()))reportPaths.add(path);
-            } catch (error) {
-                teardownErrors.push(new NodeScopeTeardownError(error, {
-                    scope: 'document',
-                    scopeId: documentRunId,
-                    node,
-                    registrationIndex
-                }));
-            }
-            finishedResult = createResult(teardownErrors);
-            if (finishError) throw finishError;
-            await options.onResult?.(finishedResult);
-            return finishedResult;
-        }
-    };
-}
-async function runCollectedCase(collectedCase, options) {
-    const phases = {
-        beforeEach: options.beforeEach ?? [],
-        steps: collectedCase.definition.steps,
-        afterEach: options.afterEach ?? []
-    };
-    const nodes = {
-        beforeEach: phases.beforeEach.map((step)=>options.resolveNode(step.node)),
-        steps: phases.steps.map((step)=>options.resolveNode(step.node)),
-        afterEach: phases.afterEach.map((step)=>options.resolveNode(step.node))
-    };
-    const runId = options.createRunId?.() ?? randomUUID();
-    const startedAt = new Date();
-    const beforeEach = [];
-    const steps = [];
-    const afterEach = [];
-    const teardownStack = [];
-    let acceptingTeardowns = true;
-    const onTeardown = (node, teardown)=>{
-        if (!acceptingTeardowns) throw new WorkflowLifecycleError('Node teardown can only be registered while a case attempt is running.', {
-            runId,
-            node
-        });
-        if ('function' != typeof teardown) throw new WorkflowLifecycleError('Node onTeardown() requires a teardown function.', {
-            runId,
-            node
-        });
-        teardownStack.push({
-            registrationIndex: teardownStack.length,
-            node,
-            teardown
-        });
-    };
-    const runPhase = async (phase, results, signal = options.signal)=>{
-        for (const [stepIndex, step] of phases[phase].entries()){
-            const caseContext = {
-                caseId: collectedCase.caseId,
-                runId,
-                projectName: options.projectName ?? collectedCase.projectId,
-                attemptIndex: options.attemptIndex ?? 0,
-                name: collectedCase.definition.name,
-                sourcePath: collectedCase.sourcePath,
-                caseIndex: collectedCase.caseIndex,
-                phase,
-                stepIndex
-            };
-            const stepInfo = {
-                scope: 'case',
-                node: step.node,
-                stepCount: phases[phase].length,
-                case: caseContext
-            };
-            await options.onStepStart?.(stepInfo);
-            const result = await executeStep(step, nodes[phase][stepIndex], {
-                scope: 'case',
-                case: caseContext
-            }, options.context, {
-                signal,
-                defaultTimeoutMs: options.defaultTimeoutMs,
-                onTeardown
-            });
-            await options.onStepResult?.(stepInfo, result);
-            results.push(result);
-            if ('failed' === result.status && !result.continuedAfterError) break;
-        }
-    };
-    let executionError;
-    try {
-        await runPhase('beforeEach', beforeEach);
-        if (!beforeEach.some((step)=>'failed' === step.status)) await runPhase('steps', steps);
-    } catch (error) {
-        executionError = error;
-    }
-    try {
-        const cleanupSignal = options.signal?.aborted ? new AbortController().signal : options.signal;
-        await runPhase('afterEach', afterEach, cleanupSignal);
-    } catch (error) {
-        executionError ??= error;
-    }
-    acceptingTeardowns = false;
-    const teardownErrors = [];
-    const reportPaths = new Set();
-    for (const { registrationIndex, node, teardown } of teardownStack.reverse())try {
-        for (const path of reportPathsFromTeardown(await teardown()))reportPaths.add(path);
-    } catch (error) {
-        teardownErrors.push(new NodeScopeTeardownError(error, {
-            scope: 'case',
-            scopeId: runId,
-            node,
-            registrationIndex
-        }));
-    }
-    if (executionError) throw executionError;
-    const endedAt = new Date();
-    const result = {
-        caseId: collectedCase.caseId,
-        runId,
-        projectName: options.projectName ?? collectedCase.projectId,
-        attemptIndex: options.attemptIndex ?? 0,
-        name: collectedCase.definition.name,
-        sourcePath: collectedCase.sourcePath,
-        caseIndex: collectedCase.caseIndex,
-        status: beforeEach.some((step)=>'failed' === step.status) || steps.some((step)=>'failed' === step.status) || afterEach.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
-        beforeEach,
-        steps,
-        afterEach,
-        ...teardownErrors.length > 0 ? {
-            teardownErrors
-        } : {},
-        ...reportPaths.size > 0 ? {
-            reportPaths: [
-                ...reportPaths
-            ]
-        } : {},
-        startedAt: startedAt.toISOString(),
-        endedAt: endedAt.toISOString(),
-        durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime())
-    };
-    await options.onResult?.(result);
-    return result;
-}
-const asNotRun = (collectedCase, projectName, reason)=>({
-        caseId: collectedCase.caseId,
-        projectName,
-        name: collectedCase.definition.name,
-        sourcePath: collectedCase.sourcePath,
-        caseIndex: collectedCase.caseIndex,
-        status: 'not-run',
-        notRunReason: reason
-    });
-async function runWorkflowDocument(document, options) {
-    const createDocumentRunId = options.createDocumentRunId;
-    const createCaseRunId = options.createCaseRunId;
-    const projectName = options.project?.name ?? document.projectId;
-    const retry = options.retry ?? options.project?.retry ?? 0;
-    if (!Number.isInteger(retry) || retry < 0) throw new TypeError('Workflow document retry must be a non-negative integer.');
-    const runtime = createDocumentRuntime(document, {
-        resolveNode: options.resolveNode,
-        project: options.project,
-        projectContext: options.projectContext,
-        signal: options.signal,
-        defaultTimeoutMs: options.defaultTimeoutMs,
-        onStepStart: options.onStepStart,
-        onStepResult: options.onStepResult,
-        onResult: options.onDocumentResult,
-        createDocumentRunId: createDocumentRunId ? ()=>createDocumentRunId(document) : void 0
-    });
-    const cases = [];
-    let runtimeStarted = false;
-    let documentResult;
-    let executionError;
-    let fatalError = false;
-    try {
-        runtimeStarted = true;
-        await runtime.start();
-        if (runtime.canRunCases) for (const collectedCase of document.cases){
-            if (fatalError || options.shouldStop?.()) {
-                const outcome = asNotRun(collectedCase, projectName, fatalError ? 'fatal-error' : options.stopReason?.() ?? 'interrupted');
-                cases.push(outcome);
-                await options.onCaseOutcome?.(outcome);
-                continue;
-            }
-            await options.onCaseStart?.(collectedCase);
-            const attempts = [];
-            for(let attemptIndex = 0; attemptIndex <= retry; attemptIndex += 1){
-                const run = await runCollectedCase(collectedCase, {
-                    resolveNode: options.resolveNode,
-                    beforeEach: document.lifecycle.beforeEach,
-                    afterEach: document.lifecycle.afterEach,
-                    context: runtime.context,
-                    projectName,
-                    attemptIndex,
-                    signal: options.signal,
-                    defaultTimeoutMs: options.defaultTimeoutMs,
-                    onStepStart: options.onStepStart,
-                    onStepResult: options.onStepResult,
-                    onResult: options.onCaseResult,
-                    createRunId: createCaseRunId ? ()=>createCaseRunId(collectedCase, attemptIndex) : void 0
-                });
-                attempts.push(run);
-                fatalError = options.isFatalError?.(run) ?? false;
-                if ('success' === run.status || fatalError) break;
-            }
-            const run = attempts.at(-1);
-            const outcome = {
-                caseId: collectedCase.caseId,
-                projectName,
-                name: collectedCase.definition.name,
-                sourcePath: collectedCase.sourcePath,
-                caseIndex: collectedCase.caseIndex,
-                status: run.status,
-                run,
-                attempts
-            };
-            cases.push(outcome);
-            await options.onCaseOutcome?.(outcome);
-        }
-        else {
-            const reason = options.signal?.aborted ? options.stopReason?.() ?? 'interrupted' : 'document-start-failed';
-            cases.push(...document.cases.map((collectedCase)=>asNotRun(collectedCase, projectName, reason)));
-        }
-    } catch (error) {
-        executionError = error;
-    } finally{
-        if (runtimeStarted) try {
-            documentResult = await runtime.finish();
-        } catch (error) {
-            executionError ??= error;
-        }
-    }
-    if (executionError) throw executionError;
-    if (!documentResult) throw new Error(`Workflow document "${document.sourcePath}" did not produce a result.`);
-    return {
-        document: documentResult,
-        cases
-    };
-}
-const supportedMetaKeys = new Set([
-    'timeout',
-    'continue-on-error'
-]);
-function isMapping(value) {
-    return 'object' == typeof value && null !== value && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
-}
-function formatStep(index) {
-    return `step ${index + 1}`;
-}
-function normalizeMeta(value, index) {
-    if (void 0 === value) return {
-        continueOnError: false
-    };
-    if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} "$" must be a mapping.`, {
-        index
-    });
-    for (const key of Object.keys(value))if (!supportedMetaKeys.has(key)) throw new WorkflowParseError(`${formatStep(index)} has unsupported engine metadata "${key}".`, {
-        index,
-        key
-    });
-    const timeout = value.timeout;
-    if (void 0 !== timeout && ('number' != typeof timeout || !Number.isFinite(timeout) || timeout <= 0)) throw new WorkflowParseError(`${formatStep(index)} "$.timeout" must be a positive number of milliseconds.`, {
-        index,
-        timeout
-    });
-    const continueOnError = value['continue-on-error'];
-    if (void 0 !== continueOnError && 'boolean' != typeof continueOnError) throw new WorkflowParseError(`${formatStep(index)} "$.continue-on-error" must be a boolean.`, {
-        index,
-        continueOnError
-    });
-    return {
-        ...void 0 === timeout ? {} : {
-            timeoutMs: timeout
-        },
-        continueOnError: continueOnError ?? false
-    };
-}
-function normalizeStep(value, index = 0, resolveNode) {
-    if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} must be a mapping.`, {
-        index
-    });
-    const entries = Object.entries(value);
-    if (1 !== entries.length) throw new WorkflowParseError(`${formatStep(index)} must contain exactly one node.`, {
-        index,
-        nodes: Object.keys(value)
-    });
-    const [node, rawValue] = entries[0];
-    if (0 === node.trim().length) throw new WorkflowParseError(`${formatStep(index)} node name must not be empty.`, {
-        index
-    });
-    if ('string' == typeof rawValue) {
-        const resolvedNode = resolveNode?.(node);
-        const stringInputKey = resolvedNode ? resolvedNode.stringInputKey : 'prompt';
-        if (false === stringInputKey || void 0 === stringInputKey) throw new WorkflowParseError(`${formatStep(index)} node "${node}" does not accept string shorthand.`, {
-            index,
-            node
-        });
-        return {
-            node,
-            input: {
-                [stringInputKey]: rawValue
-            },
-            meta: {
-                continueOnError: false
-            }
-        };
-    }
-    if (!isMapping(rawValue)) throw new WorkflowParseError(`${formatStep(index)} value must be a string shorthand or a mapping.`, {
-        index,
-        node
-    });
-    const { $: rawMeta, ...input } = rawValue;
-    return {
-        node,
-        input,
-        meta: normalizeMeta(rawMeta, index)
-    };
-}
-function normalizeSteps(steps, resolveNode) {
-    if (!Array.isArray(steps)) throw new WorkflowParseError('Steps must be an array.');
-    return steps.map((step, index)=>normalizeStep(step, index, resolveNode));
-}
+const createCaseInvocationId = (projectId, sourcePath, caseIndex, invocationIndex = 0)=>createHash('sha256').update(JSON.stringify([
+        projectId,
+        sourcePath,
+        caseIndex,
+        ...invocationIndex ? [
+            invocationIndex
+        ] : []
+    ])).digest('hex');
+const createDocumentInvocationId = (projectId, sourcePath, invocationIndex = 0)=>createHash('sha256').update(JSON.stringify([
+        projectId,
+        sourcePath,
+        ...invocationIndex ? [
+            invocationIndex
+        ] : []
+    ])).digest('hex');
+const normalize_normalizeSteps = normalizeSteps;
 const interpolationExpression = /\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}|\$\{([^{}]+)\}/g;
 const exactEnvExpression = /^\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/;
 const exactProjectExpression = /^\$\{([^{}]+)\}$/;
@@ -1346,7 +344,27 @@ const resolveWorkflowVariables = (value, options)=>{
         ]));
     return value;
 };
-const collect_isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+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;
+}
+const isMapping = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+class NativeWorkflowFormatError extends WorkflowParseError {
+    constructor(actualFormat, sourcePath){
+        super('legacy' === actualFormat ? `Legacy tasks/flow YAML is not supported by midscene-test: ${sourcePath}. Run it with \`midscene ${sourcePath}\`, or migrate the file to cases/steps.` : 'legacy-batch' === actualFormat ? `Legacy YAML batch configuration is not a midscene-test workflow document: ${sourcePath}. Run it with \`midscene --config ${sourcePath}\`, or migrate it to a native project config.` : `A workflow file cannot mix legacy tasks/flow with native cases/steps or lifecycle hooks: ${sourcePath}. Keep the formats in separate files and run each file with its matching command.`, {
+            sourcePath,
+            actualFormat,
+            expectedFormat: 'native'
+        }), _define_property(this, "actualFormat", void 0);
+        this.actualFormat = actualFormat;
+    }
+}
 const collect_rejectUnknownKeys = (value, allowed, label)=>{
     const allowedSet = new Set(allowed);
     const unknown = Object.keys(value).filter((key)=>!allowedSet.has(key));
@@ -1354,15 +372,8 @@ const collect_rejectUnknownKeys = (value, allowed, label)=>{
         field: unknown[0]
     });
 };
-const createCaseId = (projectId, sourcePath, caseIndex)=>createHash('sha256').update(JSON.stringify([
-        projectId,
-        sourcePath,
-        caseIndex
-    ])).digest('hex');
-const createWorkflowDocumentId = (projectId, sourcePath)=>createHash('sha256').update(JSON.stringify([
-        projectId,
-        sourcePath
-    ])).digest('hex');
+const createCaseId = (projectId, sourcePath, caseIndex)=>createCaseInvocationId(projectId, sourcePath, caseIndex);
+const createWorkflowDocumentId = (projectId, sourcePath)=>createDocumentInvocationId(projectId, sourcePath);
 function collectWorkflowDocument(source, options) {
     let parsed;
     try {
@@ -1374,7 +385,9 @@ function collectWorkflowDocument(source, options) {
             sourcePath: source.sourcePath
         }, error);
     }
-    if (!collect_isMapping(parsed)) throw new WorkflowParseError('Workflow document must be a mapping.');
+    if (!isMapping(parsed)) throw new WorkflowParseError('Workflow document must be a mapping.');
+    const format = classifyWorkflowDocumentFormat(parsed);
+    if ('legacy' === format || 'legacy-batch' === format || 'mixed' === format) throw new NativeWorkflowFormatError(format, source.sourcePath);
     collect_rejectUnknownKeys(parsed, [
         'beforeAll',
         'beforeEach',
@@ -1406,7 +419,7 @@ function collectWorkflowDocument(source, options) {
         if (!Array.isArray(value)) throw new WorkflowParseError(`Workflow document ${phase} must be an array.`, {
             phase
         });
-        return normalizeSteps(value, options.resolveNode).map((normalized, stepIndex)=>{
+        return normalize_normalizeSteps(value, options.resolveNode).map((normalized, stepIndex)=>{
             const resolved = options.resolveNode(normalized.node);
             if (!resolved) throw new WorkflowParseError(`Workflow document ${phase} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
                 phase,
@@ -1424,7 +437,7 @@ function collectWorkflowDocument(source, options) {
     };
     const ids = new Set();
     const cases = parsed.cases.map((definition, caseIndex)=>{
-        if (!collect_isMapping(definition)) throw new WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
+        if (!isMapping(definition)) throw new WorkflowParseError(`Case ${caseIndex + 1} must be a mapping.`, {
             caseIndex
         });
         collect_rejectUnknownKeys(definition, [
@@ -1442,7 +455,7 @@ function collectWorkflowDocument(source, options) {
         if (!Array.isArray(tags) || tags.some((tag)=>'string' != typeof tag || 0 === tag.trim().length)) throw new WorkflowParseError(`Case ${caseIndex + 1} tags must be an array of non-empty strings.`, {
             caseIndex
         });
-        const steps = normalizeSteps(definition.steps, options.resolveNode).map((normalized, stepIndex)=>{
+        const steps = normalize_normalizeSteps(definition.steps, options.resolveNode).map((normalized, stepIndex)=>{
             if (!options.resolveNode(normalized.node)) throw new WorkflowParseError(`Case ${caseIndex + 1} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
                 caseIndex,
                 stepIndex,
@@ -1450,452 +463,44 @@ function collectWorkflowDocument(source, options) {
             });
             return resolveStepVariables(normalized, 'steps', stepIndex, caseIndex);
         });
-        const caseId = createCaseId(source.projectId, sourcePath, caseIndex);
-        if (ids.has(caseId)) throw new WorkflowParseError(`Case id collision: ${caseId}.`, {
-            caseId
-        });
-        ids.add(caseId);
-        return {
-            caseId,
-            projectId: source.projectId,
-            sourcePath,
-            caseIndex,
-            definition: {
-                name: definition.name,
-                tags: tags,
-                steps
-            }
-        };
-    });
-    return {
-        documentId: createWorkflowDocumentId(source.projectId, sourcePath),
-        projectId: source.projectId,
-        sourcePath,
-        lifecycle,
-        cases
-    };
-}
-const MAX_DEPTH = 6;
-const MAX_STRING_LENGTH = 2000;
-const MAX_ARRAY_ITEMS = 50;
-const MAX_OBJECT_KEYS = 50;
-const MAX_SERIALIZED_BYTES = 65536;
-const TRUNCATED_VALUE = '[Truncated: display value exceeded 64 KiB]';
-const normalizedSecretKeys = [
-    'password',
-    'passwd',
-    'secret',
-    'token',
-    'authorization',
-    'cookie',
-    'apikey'
-];
-const normalizedKey = (key)=>key.toLowerCase().replace(/[^a-z0-9]/g, '');
-const isSecretKey = (key)=>{
-    const normalized = normalizedKey(key);
-    return normalizedSecretKeys.some((secret)=>normalized.includes(secret));
-};
-const objectPath = (parent, key)=>/^[A-Za-z_$][\w$]*$/.test(key) ? `${parent}.${key}` : `${parent}[${JSON.stringify(key)}]`;
-const stringByteLength = (value)=>Buffer.byteLength(value, 'utf8');
-function sanitizeReportText(value, maximumLength = MAX_STRING_LENGTH) {
-    return value.length <= maximumLength ? value : `${value.slice(0, maximumLength)}… [truncated]`;
-}
-function sanitizeReportValue(value) {
-    const truncatedPaths = new Set();
-    const redactedPaths = new Set();
-    const ancestors = new WeakSet();
-    let remainingBytes = MAX_SERIALIZED_BYTES;
-    const consume = (path, text)=>{
-        remainingBytes -= stringByteLength(text);
-        if (remainingBytes >= 0) return true;
-        truncatedPaths.add(path);
-        return false;
-    };
-    const visit = (current, path, depth)=>{
-        if (remainingBytes <= 0) {
-            truncatedPaths.add(path);
-            return '[Truncated: size limit]';
-        }
-        if (null === current || 'boolean' == typeof current) {
-            consume(path, String(current));
-            return current;
-        }
-        if ('string' == typeof current) {
-            if (current.length > MAX_STRING_LENGTH) {
-                truncatedPaths.add(path);
-                const shortened = `${current.slice(0, MAX_STRING_LENGTH)}… [truncated]`;
-                consume(path, shortened);
-                return shortened;
-            }
-            consume(path, current);
-            return current;
-        }
-        if ('number' == typeof current) {
-            if (Number.isFinite(current)) {
-                consume(path, String(current));
-                return current;
-            }
-            truncatedPaths.add(path);
-            return `[Unsupported number: ${String(current)}]`;
-        }
-        if ('bigint' == typeof current) {
-            truncatedPaths.add(path);
-            return `[Unsupported bigint: ${String(current)}]`;
-        }
-        if (void 0 === current || 'function' == typeof current || 'symbol' == typeof current) {
-            truncatedPaths.add(path);
-            return `[Unsupported ${typeof current}]`;
-        }
-        if (depth >= MAX_DEPTH) {
-            truncatedPaths.add(path);
-            return '[Truncated: maximum depth]';
-        }
-        if (current instanceof Date) {
-            const date = Number.isNaN(current.getTime()) ? '[Invalid Date]' : current.toISOString();
-            consume(path, date);
-            return date;
-        }
-        if (ancestors.has(current)) {
-            truncatedPaths.add(path);
-            return '[Unsupported circular value]';
-        }
-        if (Array.isArray(current)) {
-            ancestors.add(current);
-            const output = [];
-            const itemCount = Math.min(current.length, MAX_ARRAY_ITEMS);
-            for(let index = 0; index < itemCount; index += 1){
-                if (remainingBytes <= 0) break;
-                output.push(visit(current[index], `${path}[${index}]`, depth + 1));
-            }
-            if (current.length > output.length) truncatedPaths.add(path);
-            ancestors.delete(current);
-            return output;
-        }
-        const prototype = Object.getPrototypeOf(current);
-        if (prototype !== Object.prototype && null !== prototype) {
-            truncatedPaths.add(path);
-            const constructorName = current.constructor?.name ?? 'object';
-            return `[Unsupported object: ${constructorName}]`;
-        }
-        ancestors.add(current);
-        const output = {};
-        const keys = Object.keys(current);
-        for (const key of keys.slice(0, MAX_OBJECT_KEYS)){
-            const childPath = objectPath(path, key);
-            if (!consume(childPath, key)) break;
-            if (isSecretKey(key)) {
-                output[key] = '[REDACTED]';
-                redactedPaths.add(childPath);
-            } else output[key] = visit(current[key], childPath, depth + 1);
-            if (remainingBytes <= 0) break;
-        }
-        if (keys.length > Object.keys(output).length) truncatedPaths.add(path);
-        ancestors.delete(current);
-        return output;
-    };
-    const sanitized = visit(value, '$', 0);
-    const serialized = JSON.stringify(sanitized);
-    if (void 0 === serialized || stringByteLength(serialized) > MAX_SERIALIZED_BYTES) return {
-        value: TRUNCATED_VALUE,
-        truncatedPaths: [
-            '$'
-        ]
-    };
-    return {
-        value: sanitized,
-        ...truncatedPaths.size > 0 ? {
-            truncatedPaths: [
-                ...truncatedPaths
-            ]
-        } : {},
-        ...redactedPaths.size > 0 ? {
-            redactedPaths: [
-                ...redactedPaths
-            ]
-        } : {}
-    };
-}
-function sanitizeReportError(error) {
-    if (error instanceof Error) {
-        const workflowLike = error;
-        return {
-            name: sanitizeReportText(error.name || 'Error', 200),
-            message: sanitizeReportText(error.message || String(error)),
-            ...'string' == typeof workflowLike.code ? {
-                code: sanitizeReportText(workflowLike.code, 200)
-            } : {},
-            ...void 0 === workflowLike.details ? {} : {
-                details: sanitizeReportValue(workflowLike.details)
-            }
-        };
-    }
-    return {
-        name: 'Error',
-        message: sanitizeReportText(String(error))
-    };
-}
-const warnReport = getDebug('test-runner:report-assembler', {
-    console: true
-});
-const exactMidsceneDetailNodes = new Set([
-    'aiAct',
-    'aiAssert',
-    'recordToReport'
-]);
-const scopedExecutionKey = (scopeId, executionId)=>`${scopeId}\u0000${executionId}`;
-const reportSourcesForScope = (context, scopeId)=>context.sourcesByScope.get(scopeId) ?? [];
-const addDiagnostic = (context, diagnostic)=>{
-    context.diagnostics.push(diagnostic);
-    const key = JSON.stringify([
-        diagnostic.code,
-        diagnostic.scopeId,
-        diagnostic.executionId
-    ]);
-    if (!context.warnedDiagnostics.has(key)) {
-        context.warnedDiagnostics.add(key);
-        warnReport(diagnostic.message);
-    }
-};
-const buildStep = (step, scopeId, context)=>{
-    const details = [];
-    const unresolvedExecutionIds = [];
-    for (const trace of step.report?.traces ?? []){
-        const previousScope = context.tracedScopeByExecution.get(trace.executionId);
-        if (previousScope && previousScope !== scopeId) throw new Error(`Agent execution ${trace.executionId} was traced by multiple test scopes (${previousScope}, ${scopeId}).`);
-        context.tracedScopeByExecution.set(trace.executionId, scopeId);
-        const detail = context.detailsByScopeAndExecution.get(scopedExecutionKey(scopeId, trace.executionId));
-        if (detail) details.push(detail);
-        else unresolvedExecutionIds.push(trace.executionId);
-    }
-    let agentDetailDiagnostic;
-    if (unresolvedExecutionIds.length > 0) {
-        agentDetailDiagnostic = `Agent detail could not be resolved for ${unresolvedExecutionIds.join(', ')}.`;
-        const sources = reportSourcesForScope(context, scopeId);
-        for (const executionId of unresolvedExecutionIds)addDiagnostic(context, {
-            level: 'warning',
-            code: 'agent-detail-unresolved',
-            message: `Agent detail could not be resolved for execution ${executionId} in test scope ${scopeId}.`,
-            scopeId,
-            executionId,
-            ...sources.length > 0 ? {
-                sourcePaths: sources.map((source)=>source.sourcePath)
-            } : {}
-        });
-    } else if (0 === details.length && exactMidsceneDetailNodes.has(step.node)) {
-        agentDetailDiagnostic = 'This Agent did not expose a stable execution reference for the Step.';
-        addDiagnostic(context, {
-            level: 'warning',
-            code: 'agent-detail-unavailable',
-            message: `No stable Agent execution reference was captured for ${step.node} in test scope ${scopeId}.`,
-            scopeId,
-            ...reportSourcesForScope(context, scopeId).length > 0 ? {
-                sourcePaths: reportSourcesForScope(context, scopeId).map((source)=>source.sourcePath)
-            } : {}
-        });
-    }
-    const prompt = 'string' == typeof step.input?.prompt ? step.input.prompt : void 0;
-    return {
-        id: `${scopeId}:${step.phase}:${step.stepIndex}`,
-        phase: step.phase,
-        stepIndex: step.stepIndex,
-        node: step.node,
-        ...prompt ? {
-            title: sanitizeReportText(prompt, 240)
-        } : {},
-        status: step.status,
-        continuedAfterError: step.continuedAfterError,
-        startedAt: step.startedAt,
-        endedAt: step.endedAt,
-        durationMs: step.durationMs,
-        input: sanitizeReportValue(step.input),
-        ...step.output ? {
-            output: {
-                ...void 0 === step.output.summary ? {} : {
-                    summary: sanitizeReportText(step.output.summary)
-                },
-                ...void 0 === step.output.data ? {} : {
-                    data: sanitizeReportValue(step.output.data)
-                }
-            }
-        } : {},
-        ...step.error ? {
-            error: sanitizeReportError(step.error)
-        } : {},
-        ...details.length > 0 ? {
-            agentDetails: details
-        } : {},
-        ...agentDetailDiagnostic ? {
-            agentDetailDiagnostic
-        } : {}
-    };
-};
-const buildAttempt = (attempt, context)=>({
-        attemptId: attempt.runId,
-        attemptIndex: attempt.attemptIndex,
-        status: attempt.status,
-        startedAt: attempt.startedAt,
-        endedAt: attempt.endedAt,
-        durationMs: attempt.durationMs,
-        beforeEach: attempt.beforeEach.map((step)=>buildStep(step, attempt.runId, context)),
-        steps: attempt.steps.map((step)=>buildStep(step, attempt.runId, context)),
-        afterEach: attempt.afterEach.map((step)=>buildStep(step, attempt.runId, context)),
-        ...attempt.teardownErrors?.length ? {
-            teardownErrors: attempt.teardownErrors.map(sanitizeReportError)
-        } : {},
-        ...reportSourcesForScope(context, attempt.runId).length > 0 ? {
-            scopeReportIds: reportSourcesForScope(context, attempt.runId).map((source)=>source.reportId)
-        } : {}
-    });
-const buildCase = (outcome, context)=>({
-        caseId: outcome.caseId,
-        name: outcome.name,
-        caseIndex: outcome.caseIndex,
-        status: outcome.status,
-        ...outcome.notRunReason ? {
-            notRunReason: outcome.notRunReason
-        } : {},
-        attempts: (outcome.attempts ?? (outcome.run ? [
-            outcome.run
-        ] : [])).map((attempt)=>buildAttempt(attempt, context))
-    });
-const buildDocument = (documentId, document, cases, context)=>{
-    const sourcePath = document?.sourcePath ?? cases[0]?.sourcePath ?? '<unknown>';
-    const status = document?.status ?? (cases.some((item)=>'success' !== item.status) ? 'failed' : 'success');
-    return {
-        documentId,
-        sourcePath,
-        status,
-        ...document ? {
-            startedAt: document.startedAt,
-            endedAt: document.endedAt,
-            durationMs: document.durationMs
-        } : {},
-        beforeAll: (document?.beforeAll ?? []).map((step)=>buildStep(step, document.documentRunId, context)),
-        cases: cases.map((outcome)=>buildCase(outcome, context)),
-        afterAll: (document?.afterAll ?? []).map((step)=>buildStep(step, document.documentRunId, context)),
-        ...document?.teardownErrors?.length ? {
-            teardownErrors: document.teardownErrors.map(sanitizeReportError)
-        } : {},
-        ...document && reportSourcesForScope(context, document.documentRunId).length > 0 ? {
-            scopeReportIds: reportSourcesForScope(context, document.documentRunId).map((source)=>source.reportId)
-        } : {}
-    };
-};
-const buildProject = (project, context)=>{
-    const documentById = new Map(project.documents.map((document)=>[
-            document.documentId,
-            document
-        ]));
-    const casesByDocumentId = new Map();
-    for (const outcome of project.cases){
-        const current = casesByDocumentId.get(outcome.documentId) ?? [];
-        current.push(outcome);
-        casesByDocumentId.set(outcome.documentId, current);
-    }
-    const documentIds = new Set([
-        ...project.documents.map((document)=>document.documentId),
-        ...project.cases.map((outcome)=>outcome.documentId)
-    ]);
-    return {
-        projectId: project.projectId,
-        name: project.name,
-        status: project.status,
-        retry: project.retry,
-        ...project.lifecycle ? {
-            lifecycle: {
-                status: project.lifecycle.status,
-                startedAt: project.lifecycle.startedAt,
-                endedAt: project.lifecycle.endedAt,
-                durationMs: project.lifecycle.durationMs,
-                ...project.lifecycle.setupError ? {
-                    setupError: sanitizeReportError(project.lifecycle.setupError)
-                } : {},
-                ...project.lifecycle.teardownErrors?.length ? {
-                    teardownErrors: project.lifecycle.teardownErrors.map(sanitizeReportError)
-                } : {}
-            }
-        } : {},
-        documents: [
-            ...documentIds
-        ].map((documentId)=>buildDocument(documentId, documentById.get(documentId), casesByDocumentId.get(documentId) ?? [], context)),
-        collectionErrors: project.collectionErrors.map((collectionError)=>({
-                sourcePath: collectionError.sourcePath,
-                error: sanitizeReportError(collectionError.error)
-            }))
-    };
-};
-function collectTestRunReportSources(result) {
-    const sources = [];
-    for (const project of result.projects){
-        for (const document of project.documents)for (const sourcePath of document.reportPaths ?? [])sources.push({
-            scopeId: document.documentRunId,
-            sourcePath
-        });
-        for (const outcome of project.cases)for (const attempt of outcome.attempts ?? (outcome.run ? [
-            outcome.run
-        ] : []))for (const sourcePath of attempt.reportPaths ?? [])sources.push({
-            scopeId: attempt.runId,
-            sourcePath
-        });
-    }
-    return sources;
-}
-function buildTestRunReportDump(result, index) {
-    const sourcesByScope = new Map();
-    const detailsByScopeAndExecution = new Map();
-    for (const source of index.sources){
-        const scopeSources = sourcesByScope.get(source.scopeId) ?? [];
-        scopeSources.push(source);
-        sourcesByScope.set(source.scopeId, scopeSources);
-        for (const executionId of source.executionIds)detailsByScopeAndExecution.set(scopedExecutionKey(source.scopeId, executionId), {
-            reportId: source.reportId,
-            executionId
+        const caseId = createCaseId(source.projectId, sourcePath, caseIndex);
+        if (ids.has(caseId)) throw new WorkflowParseError(`Case id collision: ${caseId}.`, {
+            caseId
         });
-    }
-    const context = {
-        diagnostics: [],
-        sourcesByScope,
-        detailsByScopeAndExecution,
-        tracedScopeByExecution: new Map(),
-        warnedDiagnostics: new Set()
-    };
-    for (const source of index.sources)if (0 === source.executionIds.length) addDiagnostic(context, {
-        level: 'warning',
-        code: 'source-without-executions',
-        message: `Agent report contains no executions: ${source.sourcePath}`,
-        scopeId: source.scopeId,
-        sourcePaths: [
-            source.sourcePath
-        ]
+        ids.add(caseId);
+        return {
+            caseId,
+            projectId: source.projectId,
+            sourcePath,
+            caseIndex,
+            definition: {
+                name: definition.name,
+                tags: tags,
+                steps
+            }
+        };
     });
-    const projects = result.projects.map((project)=>buildProject(project, context));
     return {
-        schemaVersion: 1,
-        kind: 'test-runner',
-        runId: result.runId,
-        status: result.status,
-        startedAt: result.startedAt,
-        endedAt: result.endedAt,
-        durationMs: result.durationMs,
-        summary: {
-            ...result.summary
-        },
-        metrics: index.metrics,
-        projects,
-        ...context.diagnostics.length > 0 ? {
-            diagnostics: context.diagnostics
-        } : {}
+        documentId: createWorkflowDocumentId(source.projectId, sourcePath),
+        projectId: source.projectId,
+        sourcePath,
+        lifecycle,
+        cases
     };
 }
-const writeJson = (path, value)=>{
-    mkdirSync(dirname(path), {
-        recursive: true
-    });
-    writeFileSync(path, JSON.stringify(value, null, 2));
+const writeJson = async (path, value)=>{
+    try {
+        await mkdir(dirname(path), {
+            recursive: true
+        });
+        await writeFile(path, JSON.stringify(value, null, 2));
+    } catch (error) {
+        throw new WorkflowPublicationError('write-result', path, error);
+    }
 };
 const toPosix = (value)=>value.split(sep).join('/');
 const caseAttemptResultPath = (projectId, documentId, result)=>toPosix(join(projectId, 'documents', documentId, 'cases', result.caseId, `${result.runId}.json`));
-const workflowDocumentResultPath = (result)=>toPosix(join(result.projectId, 'documents', result.documentId, 'document.json'));
+const workflowDocumentResultPath = (result)=>toPosix(join(result.projectId, 'documents', result.documentId, void 0 === result.attemptIndex ? 'document.json' : `${result.documentRunId}.json`));
 const collectionErrorPath = (projectId, sourcePath)=>{
     const id = createHash('sha256').update(JSON.stringify([
         projectId,
@@ -1905,21 +510,19 @@ const collectionErrorPath = (projectId, sourcePath)=>{
 };
 const writeWorkflowDocumentResult = (runDir, result)=>{
     const { documentRunId: _documentRunId, ...persistedResult } = result;
-    writeJson(join(runDir, workflowDocumentResultPath(result)), persistedResult);
+    return writeJson(join(runDir, workflowDocumentResultPath(result)), persistedResult);
 };
 const writeCaseAttemptResult = (runDir, projectId, documentId, result)=>{
     const { runId: attemptId, ...persistedResult } = result;
-    writeJson(join(runDir, caseAttemptResultPath(projectId, documentId, result)), {
+    return writeJson(join(runDir, caseAttemptResultPath(projectId, documentId, result)), {
         ...persistedResult,
         attemptId
     });
 };
-const writeCollectionError = (runDir, collectionError)=>{
-    writeJson(join(runDir, collectionErrorPath(collectionError.projectId, collectionError.sourcePath)), {
+const writeCollectionError = (runDir, collectionError)=>writeJson(join(runDir, collectionErrorPath(collectionError.projectId, collectionError.sourcePath)), {
         kind: 'collection-error',
         ...collectionError
     });
-};
 const relativeToSummary = (summaryPath, target)=>{
     const value = relative(dirname(summaryPath), target);
     return toPosix(value || '.');
@@ -1928,7 +531,7 @@ const errorJson = (error)=>error instanceof Error && 'toJSON' in error ? error.t
 const writeTestProjectRunResult = (options)=>{
     const { result } = options;
     const fact = (path)=>toPosix(path);
-    writeJson(result.summaryPath, {
+    return writeJson(result.summaryPath, {
         schemaVersion: result.schemaVersion,
         runId: result.runId,
         startedAt: result.startedAt,
@@ -1936,6 +539,9 @@ const writeTestProjectRunResult = (options)=>{
         durationMs: result.durationMs,
         status: result.status,
         exitCode: result.exitCode,
+        ...result.errors?.length ? {
+            errors: result.errors.map(errorJson)
+        } : {},
         projectRoot: options.projectRoot,
         ...options.configPath ? {
             configPath: options.configPath
@@ -1971,6 +577,9 @@ const writeTestProjectRunResult = (options)=>{
                     }
                 } : {},
                 cases: project.cases.map((outcome)=>({
+                        ...outcome.documentRunId ? {
+                            documentRunId: outcome.documentRunId
+                        } : {},
                         documentId: outcome.documentId,
                         caseId: outcome.caseId,
                         sourcePath: outcome.sourcePath,
@@ -1994,6 +603,10 @@ const writeTestProjectRunResult = (options)=>{
                     })),
                 documents: project.documents.map((document)=>({
                         documentId: document.documentId,
+                        ...void 0 === document.attemptIndex ? {} : {
+                            attemptIndex: document.attemptIndex,
+                            documentRunId: document.documentRunId
+                        },
                         sourcePath: document.sourcePath,
                         status: document.status,
                         resultFile: fact(workflowDocumentResultPath(document)),
@@ -2028,32 +641,36 @@ const DEFAULT_TEST_FILE_SELECTION = {
         '**/*.{yaml,yml}'
     ]
 };
-const test_project_runner_toPosix = (value)=>value.split(sep).join('/');
-const discoverTestFiles = (projectRoot, selection = DEFAULT_TEST_FILE_SELECTION)=>{
+const project_preparation_toPosix = (value)=>value.split(sep).join('/');
+const discoverResolvedTestFiles = (projectRoot, selection)=>{
     const root = resolve(projectRoot);
-    const normalized = validateTestFileSelection(selection);
-    if (!normalized) throw new TypeError('Test file selection is required.');
-    const files = globSync(normalized.include, {
-        absolute: true,
-        caseSensitiveMatch: false,
-        cwd: root,
-        dot: true,
-        expandDirectories: false,
-        followSymbolicLinks: false,
-        ignore: [
-            ...ALWAYS_IGNORED_PATTERNS,
-            ...normalized.exclude ?? []
-        ],
-        onlyFiles: true
-    }).filter((file)=>/\.ya?ml$/i.test(file));
+    const match = (patterns)=>globSync(patterns, {
+            absolute: true,
+            caseSensitiveMatch: false,
+            cwd: root,
+            dot: true,
+            expandDirectories: false,
+            followSymbolicLinks: false,
+            ignore: [
+                ...ALWAYS_IGNORED_PATTERNS,
+                ...selection.exclude ?? []
+            ],
+            onlyFiles: true
+        }).filter((file)=>/\.ya?ml$/i.test(file));
+    const files = match(selection.include);
     return [
         ...new Set(files.map((file)=>resolve(file)))
     ].sort((a, b)=>{
-        const relativeA = test_project_runner_toPosix(relative(root, a));
-        const relativeB = test_project_runner_toPosix(relative(root, b));
+        const relativeA = project_preparation_toPosix(relative(root, a));
+        const relativeB = project_preparation_toPosix(relative(root, b));
         return relativeA < relativeB ? -1 : relativeA > relativeB ? 1 : 0;
     });
 };
+const discoverTestFiles = (projectRoot, selection = DEFAULT_TEST_FILE_SELECTION)=>{
+    const normalized = validateTestFileSelection(selection);
+    if (!normalized) throw new TypeError('Test file selection is required.');
+    return discoverResolvedTestFiles(projectRoot, normalized);
+};
 const discoverTestConfig = (projectRoot)=>{
     const root = resolve(projectRoot);
     const candidates = readdirSync(root).filter((name)=>name.startsWith(CONFIG_PREFIX)).sort();
@@ -2071,22 +688,6 @@ const discoverTestConfig = (projectRoot)=>{
     ].join('\n'));
     return supported[0] ? join(root, supported[0]) : void 0;
 };
-const defaultResultDir = (projectRoot)=>join(projectRoot, '.midscene', 'test-results');
-const padDatePart = (value)=>String(value).padStart(2, '0');
-const createTestRunId = (date = new Date(), uuid = randomUUID())=>{
-    const timestamp = [
-        date.getFullYear(),
-        padDatePart(date.getMonth() + 1),
-        padDatePart(date.getDate()),
-        padDatePart(date.getHours()),
-        padDatePart(date.getMinutes()),
-        padDatePart(date.getSeconds())
-    ].join('');
-    return `${timestamp}-${uuid.slice(0, 8)}`;
-};
-const assertDirectory = (path, label)=>{
-    if (!existsSync(path) || !statSync(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
-};
 const asCollectionError = (projectId, projectName, sourcePath, error)=>({
         projectId,
         projectName,
@@ -2113,52 +714,6 @@ const filterDocumentCases = (document, project)=>{
         filtered
     };
 };
-const test_project_runner_asNotRun = (documentId, collectedCase, projectName, reason)=>({
-        documentId,
-        caseId: collectedCase.caseId,
-        projectName,
-        name: collectedCase.definition.name,
-        sourcePath: collectedCase.sourcePath,
-        caseIndex: collectedCase.caseIndex,
-        status: 'not-run',
-        notRunReason: reason
-    });
-const summarize = (projects)=>{
-    const cases = projects.flatMap((project)=>project.cases);
-    const documents = projects.flatMap((project)=>project.documents);
-    return {
-        total: cases.length,
-        passed: cases.filter((item)=>'success' === item.status).length,
-        failed: cases.filter((item)=>'failed' === item.status).length,
-        notRun: cases.filter((item)=>'not-run' === item.status).length,
-        filtered: projects.reduce((total, project)=>total + project.filteredCaseCount, 0),
-        collectionErrors: projects.reduce((total, project)=>total + project.collectionErrors.length, 0),
-        documentFailures: documents.filter((document)=>'failed' === document.status).length,
-        projectFailures: projects.filter((project)=>'failed' === project.status).length
-    };
-};
-const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
-const test_project_runner_formatStep = (info)=>{
-    const position = stepPosition(info);
-    const phase = 'steps' === position.phase ? 'step' : position.phase;
-    return `${phase} ${position.stepIndex + 1}/${info.stepCount}: ${info.node}`;
-};
-const formatStepResult = (info, result)=>{
-    const indent = 'case' === info.scope ? '      ' : '    ';
-    const symbol = 'success' === result.status ? '✓' : '✗';
-    const error = result.error ? ` — ${result.error.message}` : '';
-    const continuation = result.continuedAfterError ? '; continuing' : '';
-    return `${indent}${symbol} ${test_project_runner_formatStep(info)} (${result.durationMs} ms)${error}${continuation}`;
-};
-const caseHasFatalError = (outcome)=>(outcome.attempts ?? []).some((attempt)=>[
-            ...attempt.beforeEach,
-            ...attempt.steps,
-            ...attempt.afterEach
-        ].some((step)=>step.error && isFatalDeviceError(step.error)) || (attempt.teardownErrors ?? []).some(isFatalDeviceError));
-const documentHasFatalError = (result)=>[
-        ...result.beforeAll,
-        ...result.afterAll
-    ].some((step)=>step.error && isFatalDeviceError(step.error)) || (result.teardownErrors ?? []).some(isFatalDeviceError);
 const selectProjects = (projects, names)=>{
     if (!names || 0 === names.length) return projects;
     const requested = new Set(names);
@@ -2168,17 +723,30 @@ const selectProjects = (projects, names)=>{
     if (unknown) throw new Error(`Unknown Midscene project: ${unknown}`);
     return projects.filter((project)=>requested.has(project.name));
 };
-const prepareProject = (project, projectRoot, runDir)=>{
+async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, options = {}) {
     const fileSelection = project.files ?? DEFAULT_TEST_FILE_SELECTION;
-    const files = discoverTestFiles(projectRoot, fileSelection);
-    const sources = files.map((absolutePath)=>({
+    const prerequisiteFile = options.prerequisiteFile ? resolve(options.prerequisiteFile) : void 0;
+    const mainFiles = options.files ?? discoverResolvedTestFiles(projectRoot, fileSelection);
+    const files = [
+        ...prerequisiteFile ? [
+            prerequisiteFile
+        ] : [],
+        ...mainFiles.filter((file)=>file !== prerequisiteFile)
+    ];
+    const occurrences = new Map();
+    const sources = files.map((absolutePath)=>{
+        const invocationIndex = occurrences.get(absolutePath) ?? 0;
+        occurrences.set(absolutePath, invocationIndex + 1);
+        return {
             projectId: project.projectId,
             projectName: project.name,
-            sourcePath: test_project_runner_toPosix(relative(projectRoot, absolutePath)),
-            absolutePath
-        }));
+            sourcePath: project_preparation_toPosix(relative(projectRoot, absolutePath)),
+            absolutePath,
+            invocationIndex
+        };
+    });
     const collectionErrors = [];
-    const documents = [];
+    const invocations = [];
     let filteredCaseCount = 0;
     if (0 === sources.length) {
         const error = asCollectionError(project.projectId, project.name, '<project>', new WorkflowParseError(`No workflow YAML files found for project "${project.name}" in ${projectRoot}.`, {
@@ -2186,56 +754,282 @@ const prepareProject = (project, projectRoot, runDir)=>{
             projectRoot
         }));
         collectionErrors.push(error);
-        writeCollectionError(runDir, error);
+        await writeCollectionError(runDir, error);
     }
     for (const source of sources)try {
-        const collected = collectWorkflowDocument(source, {
+        const collected = await options.collectDocument?.(source, project);
+        if (collected) {
+            filteredCaseCount += collected.filteredCaseCount;
+            if (collected.invocation) invocations.push(collected.invocation);
+            continue;
+        }
+        const document = collectWorkflowDocument(source, {
             resolveNode: project.nodes.get.bind(project.nodes),
             variables: project.variables,
             env: process.env
         });
-        const filtered = filterDocumentCases(collected, project);
+        const filtered = source.absolutePath === prerequisiteFile ? {
+            document,
+            filtered: 0
+        } : filterDocumentCases(document, project);
         filteredCaseCount += filtered.filtered;
-        if (filtered.document) documents.push(filtered.document);
+        if (filtered.document) invocations.push({
+            document: filtered.document,
+            retry: {
+                scope: 'case',
+                count: project.retry
+            },
+            defaultTimeoutMs,
+            reportEnabled: true,
+            bindings: {
+                resolveNode: project.nodes.require.bind(project.nodes)
+            }
+        });
     } catch (error) {
         const collectionError = asCollectionError(project.projectId, project.name, source.sourcePath, error);
         collectionErrors.push(collectionError);
-        writeCollectionError(runDir, collectionError);
+        await writeCollectionError(runDir, collectionError);
     }
+    const documents = invocations.map((invocation)=>invocation.document);
+    const prerequisiteSource = sources.find((source)=>source.absolutePath === prerequisiteFile);
+    const prerequisiteDocument = documents.find((document)=>document.sourcePath === prerequisiteSource?.sourcePath);
     return {
         project,
+        platform: options.platform ?? 'test',
+        documentConcurrency: options.documentConcurrency ?? 1,
+        ...prerequisiteDocument ? {
+            prerequisiteDocumentId: prerequisiteDocument.documentId
+        } : {},
         fileSelection,
         sources,
         documents,
+        invocations,
         collectionErrors,
         selectedCaseCount: documents.reduce((total, document)=>total + document.cases.length, 0),
         filteredCaseCount
     };
+}
+const padDatePart = (value)=>String(value).padStart(2, '0');
+const createTestRunId = (date = new Date(), uuid = randomUUID())=>{
+    const timestamp = [
+        date.getFullYear(),
+        padDatePart(date.getMonth() + 1),
+        padDatePart(date.getDate()),
+        padDatePart(date.getHours()),
+        padDatePart(date.getMinutes()),
+        padDatePart(date.getSeconds())
+    ].join('');
+    return `${timestamp}-${uuid.slice(0, 8)}`;
 };
-const notRunSuite = (prepared, reason)=>prepared.documents.flatMap((document)=>document.cases.map((item)=>test_project_runner_asNotRun(document.documentId, item, prepared.project.name, reason)));
-async function runTestProject(options = {}) {
-    const startedAt = new Date();
-    const runId = createTestRunId(startedAt);
+const assertDirectory = (path, label)=>{
+    if (!existsSync(path) || !statSync(path).isDirectory()) throw new Error(`${label} does not exist or is not a directory: ${path}`);
+};
+const resolveRunInput = (options)=>{
     const cwd = resolve(options.cwd ?? process.cwd());
     assertDirectory(cwd, 'Test working directory');
-    const cliProjectRoot = options.projectRoot ? resolve(cwd, options.projectRoot) : void 0;
+    const inputPath = options.projectRoot ? resolve(cwd, options.projectRoot) : void 0;
+    const singleFile = inputPath && existsSync(inputPath) && statSync(inputPath).isFile() ? inputPath : void 0;
+    if (singleFile && !/\.ya?ml$/i.test(singleFile)) throw new Error(`Test input must be a YAML file or project directory: ${singleFile}`);
+    const cliProjectRoot = singleFile ? dirname(singleFile) : inputPath;
     if (cliProjectRoot) assertDirectory(cliProjectRoot, 'Test project directory');
-    const configSearchRoot = cliProjectRoot ?? cwd;
-    const configPath = options.configPath ? resolve(configSearchRoot, options.configPath) : discoverTestConfig(configSearchRoot);
-    if (options.configPath && (!configPath || !existsSync(configPath))) throw new Error(`Midscene config does not exist: ${configPath}`);
-    const definition = await loadTestProject(configPath);
     const projectRoot = cliProjectRoot ?? cwd;
-    const resultDir = options.resultDir ? resolve(cwd, options.resultDir) : defaultResultDir(projectRoot);
+    return {
+        cwd,
+        projectRoot,
+        configSearchRoot: projectRoot,
+        ...singleFile ? {
+            singleFile
+        } : {}
+    };
+};
+async function prepareTestRun(options) {
+    const startedAt = new Date();
+    const runId = createTestRunId(startedAt);
+    const input = resolveRunInput(options);
+    const configPath = options.configPath ? resolve(input.configSearchRoot, options.configPath) : discoverTestConfig(input.configSearchRoot);
+    if (options.configPath && /\.ya?ml$/i.test(configPath)) throw new Error(`midscene-test --config only accepts a native TypeScript or JavaScript project config: ${configPath}. Run legacy batch YAML with \`midscene --config ${options.configPath}\`.`);
+    if (options.configPath && !existsSync(configPath)) throw new Error(`Midscene config does not exist: ${configPath}`);
+    const definition = await loadTestProject(configPath);
+    const resultDir = options.resultDir ? resolve(input.cwd, options.resultDir) : join(input.projectRoot, '.midscene', 'test-results');
     const runDir = join(resultDir, runId);
     const summaryPath = join(runDir, 'summary.json');
-    const reportDir = resolve(projectRoot, definition.output.reportDir);
+    const reportDir = resolve(input.projectRoot, definition.output.reportDir);
     mkdirSync(resultDir, {
         recursive: true
     });
     mkdirSync(runDir);
-    const selectedProjects = selectProjects(definition.projects, options.projectNames);
-    const preparedProjects = selectedProjects.map((project)=>prepareProject(project, projectRoot, runDir));
-    const progress = options.onProgress ?? (()=>{});
+    const projects = [];
+    for (const project of selectProjects(definition.projects, options.projectNames))projects.push(await prepareProject(project, input.projectRoot, runDir, definition.test.testTimeout, input.singleFile ? {
+        files: [
+            input.singleFile
+        ]
+    } : void 0));
+    const hasFormatMismatch = projects.some((project)=>project.collectionErrors.some(({ error })=>error instanceof NativeWorkflowFormatError));
+    return {
+        startedAt,
+        runId,
+        projectRoot: input.projectRoot,
+        ...configPath ? {
+            configPath
+        } : {},
+        resultDir,
+        runDir,
+        summaryPath,
+        reportDir,
+        definition,
+        projects,
+        preflightScope: hasFormatMismatch ? 'run' : 'project',
+        reportEnabled: true,
+        publications: [],
+        onProgress: options.onProgress ?? (()=>{})
+    };
+}
+const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
+const formatStep = (info)=>{
+    const position = stepPosition(info);
+    const phase = 'steps' === position.phase ? 'step' : position.phase;
+    return `${phase} ${position.stepIndex + 1}/${info.stepCount}: ${info.node}`;
+};
+const formatStepResult = (info, result)=>{
+    const indent = 'case' === info.scope ? '      ' : '    ';
+    const symbol = 'success' === result.status ? '✓' : '✗';
+    const error = result.error ? ` — ${result.error.message}` : '';
+    const continuation = result.continuedAfterError ? '; continuing' : '';
+    return `${indent}${symbol} ${formatStep(info)} (${result.durationMs} ms)${error}${continuation}`;
+};
+const caseHasFatalError = (outcome)=>(outcome.attempts ?? []).some((attempt)=>[
+            ...attempt.beforeEach,
+            ...attempt.steps,
+            ...attempt.afterEach
+        ].some((step)=>step.error && isFatalDeviceError(step.error)) || (attempt.teardownErrors ?? []).some(isFatalDeviceError));
+const documentHasFatalError = (result)=>[
+        ...result.beforeAll,
+        ...result.afterAll
+    ].some((step)=>step.error && isFatalDeviceError(step.error)) || (result.teardownErrors ?? []).some(isFatalDeviceError);
+async function executeDocumentInvocation(options) {
+    const { invocation, project, sinks } = options;
+    const { document } = invocation;
+    const documentRetry = 'document' === invocation.retry.scope;
+    const attempts = [];
+    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, {
+            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)=>{
+            if (error instanceof WorkflowExecutionFailure) {
+                const partial = error.result;
+                attempts.push(partial);
+                sinks.documents.push(partial.document);
+                sinks.cases.push(...partial.cases.map((outcome)=>({
+                        ...outcome,
+                        documentId: document.documentId,
+                        documentRunId: partial.document.documentRunId
+                    })));
+                try {
+                    await writeWorkflowDocumentResult(options.runDir, partial.document);
+                } catch (publicationError) {
+                    throw new WorkflowExecutionFailure(partial, [
+                        ...error.errors,
+                        publicationError
+                    ]);
+                }
+            }
+            throw error;
+        });
+        attempts.push(execution);
+        sinks.cases.push(...execution.cases.map((outcome)=>({
+                ...outcome,
+                documentId: document.documentId,
+                documentRunId: execution.document.documentRunId
+            })));
+        sinks.documents.push(execution.document);
+        await writeWorkflowDocumentResult(options.runDir, execution.document);
+        if (documentHasFatalError(execution.document)) options.markProjectFatal();
+        const cleanupErrors = [
+            ...execution.document.teardownErrors ?? [],
+            ...execution.cases.flatMap((outcome)=>(outcome.attempts ?? []).flatMap((attempt)=>attempt.teardownErrors ?? []))
+        ];
+        if (cleanupErrors.length) throw new WorkflowExecutionFailure(execution, cleanupErrors);
+        const failed = 'failed' === execution.document.status || execution.cases.some((item)=>'success' !== item.status);
+        return failed ? 'failed' : 'success';
+    });
+    const final = attempts.at(-1);
+    if (!final) return;
+    const failedCases = final.cases.filter((item)=>'failed' === item.status).length;
+    if (documentRetry && failedCases) options.addFailedCases(failedCases);
+    else if ('failed' === final.document.status && 0 === failedCases) options.addFailedCases(Math.max(1, failedCases));
+}
+const asNotRun = (documentId, collectedCase, projectName, reason)=>({
+        documentId,
+        caseId: collectedCase.caseId,
+        projectName,
+        name: collectedCase.definition.name,
+        sourcePath: collectedCase.sourcePath,
+        caseIndex: collectedCase.caseIndex,
+        status: 'not-run',
+        notRunReason: reason
+    });
+const summarize = (projects)=>{
+    const cases = projects.flatMap((project)=>latestById(project.cases, (item)=>item.caseId));
+    const documents = projects.flatMap((project)=>latestById(project.documents, (item)=>item.documentId));
+    return {
+        total: cases.length,
+        passed: cases.filter((item)=>'success' === item.status).length,
+        failed: cases.filter((item)=>'failed' === item.status).length,
+        notRun: cases.filter((item)=>'not-run' === item.status).length,
+        filtered: projects.reduce((total, project)=>total + project.filteredCaseCount, 0),
+        collectionErrors: projects.reduce((total, project)=>total + project.collectionErrors.length, 0),
+        documentFailures: documents.filter((document)=>'failed' === document.status).length,
+        projectFailures: projects.filter((project)=>'failed' === project.status).length
+    };
+};
+const latestById = (items, id)=>[
+        ...new Map(items.map((item)=>[
+                id(item),
+                item
+            ])).values()
+    ];
+const notRunSuite = (prepared, reason)=>prepared.documents.flatMap((document)=>document.cases.map((item)=>asNotRun(document.documentId, item, prepared.project.name, reason)));
+async function runPreparedTestProject(plan) {
+    const { startedAt, runId, projectRoot, configPath, resultDir, runDir, summaryPath, reportDir, definition, projects: preparedProjects } = plan;
+    const progress = plan.onProgress;
     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);
@@ -2253,11 +1047,13 @@ async function runTestProject(options = {}) {
     let failedCaseCount = 0;
     const bailReached = ()=>definition.test.bail > 0 && failedCaseCount >= definition.test.bail;
     let hasInfrastructureError = false;
-    let firstInfrastructureError;
+    const infrastructureErrors = [];
     const recordInfrastructureError = (error)=>{
-        if (hasInfrastructureError) return;
+        const errors = error instanceof WorkflowExecutionFailure ? error.errors : [
+            error
+        ];
+        for (const item of errors)if (!infrastructureErrors.includes(item)) infrastructureErrors.push(item);
         hasInfrastructureError = true;
-        firstInfrastructureError = error;
         rootController.abort(error);
     };
     const runInfrastructureCallback = (callback)=>{
@@ -2274,10 +1070,11 @@ async function runTestProject(options = {}) {
     };
     const buildProjectResult = (prepared, cases, documents, lifecycle)=>{
         const { project } = prepared;
-        const projectFailed = prepared.collectionErrors.length > 0 || cases.some((item)=>'success' !== item.status) || documents.some((item)=>'failed' === item.status) || lifecycle?.status === 'failed';
+        const projectFailed = prepared.collectionErrors.length > 0 || latestById(cases, (item)=>item.caseId).some((item)=>'success' !== item.status) || latestById(documents, (item)=>item.documentId).some((item)=>'failed' === item.status) || lifecycle?.status === 'failed';
         return {
             projectId: project.projectId,
             name: project.name,
+            platform: prepared.platform,
             status: projectFailed ? 'failed' : 'success',
             retry: project.retry,
             fileSelection: prepared.fileSelection,
@@ -2305,7 +1102,7 @@ async function runTestProject(options = {}) {
         const documents = [];
         let lifecycle;
         let projectFatal = false;
-        if (prepared.collectionErrors.length > 0) cases.push(...notRunSuite(prepared, 'project-preflight-failed'));
+        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 {
@@ -2315,96 +1112,101 @@ async function runTestProject(options = {}) {
                 signal: rootController.signal
             });
             let hasProjectExecutionError = false;
-            let projectExecutionError;
             try {
                 await runtime.start();
-                if (runtime.canRun) for (const [documentIndex, document] of prepared.documents.entries()){
-                    if (rootController.signal.aborted || bailReached() || projectFatal) {
-                        const reason = rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail';
-                        cases.push(...document.cases.map((item)=>test_project_runner_asNotRun(document.documentId, item, project.name, reason)));
-                        continue;
+                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);
                     }
-                    projectProgress(`  [document ${documentIndex + 1}/${prepared.documents.length}] ${document.sourcePath}`);
-                    const execution = await runWorkflowDocument(document, {
-                        resolveNode: project.nodes.require.bind(project.nodes),
-                        project,
-                        projectContext: runtime.context,
-                        retry: project.retry,
-                        signal: runtime.signal,
-                        defaultTimeoutMs: definition.test.testTimeout,
-                        shouldStop: ()=>rootController.signal.aborted || bailReached() || projectFatal,
-                        stopReason: ()=>rootController.signal.aborted ? 'interrupted' : projectFatal ? 'fatal-error' : 'bail',
-                        isFatalError: (run)=>[
-                                ...run.beforeEach,
-                                ...run.steps,
-                                ...run.afterEach
-                            ].some((step)=>step.error && isFatalDeviceError(step.error)) || (run.teardownErrors ?? []).some(isFatalDeviceError),
-                        onCaseStart: (collectedCase)=>{
-                            projectProgress(`    [case ${collectedCase.caseIndex + 1}/${document.cases.length}] ${collectedCase.definition.name}`);
-                        },
-                        onStepStart: (info)=>{
-                            const indent = 'case' === info.scope ? '      ' : '    ';
-                            projectProgress(`${indent}→ ${test_project_runner_formatStep(info)}`);
-                        },
-                        onStepResult: (info, result)=>projectProgress(formatStepResult(info, result)),
-                        onCaseResult: (attempt)=>{
-                            runInfrastructureCallback(()=>writeCaseAttemptResult(runDir, project.projectId, document.documentId, attempt));
-                            projectProgress(`    ${'success' === attempt.status ? '✓' : '✗'} attempt ${attempt.attemptIndex + 1}/${project.retry + 1}: ${attempt.name} (${attempt.durationMs} ms)`);
-                        },
-                        onCaseOutcome: (outcome)=>{
-                            if ('failed' === outcome.status) failedCaseCount += 1;
-                            if (caseHasFatalError(outcome)) projectFatal = true;
-                        },
-                        onDocumentResult: (documentResult)=>runInfrastructureCallback(()=>writeWorkflowDocumentResult(runDir, documentResult))
+                    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;
+                        }
                     });
-                    cases.push(...execution.cases.map((outcome)=>({
-                            ...outcome,
-                            documentId: document.documentId
-                        })));
-                    if (documentHasFatalError(execution.document)) projectFatal = true;
-                    documents.push(execution.document);
-                }
-                else cases.push(...notRunSuite(prepared, rootController.signal.aborted ? 'interrupted' : 'project-setup-failed'));
+                    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;
-                projectExecutionError = error;
                 recordInfrastructureError(error);
             } finally{
-                const hasFailure = hasProjectExecutionError || cases.some((item)=>'success' !== item.status) || documents.some((item)=>'failed' === item.status) || projectFatal || rootController.signal.aborted;
+                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) throw projectExecutionError;
+            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);
-    let nextProjectIndex = 0;
-    const claimNextProject = ()=>{
-        if (hasInfrastructureError || rootController.signal.aborted || bailReached() || nextProjectIndex >= preparedProjects.length) return;
-        const projectIndex = nextProjectIndex;
-        nextProjectIndex += 1;
-        return projectIndex;
-    };
-    const worker = async ()=>{
-        try {
-            while(true){
-                const projectIndex = claimNextProject();
-                if (void 0 === projectIndex) return;
-                projectResults[projectIndex] = await runPreparedProject(preparedProjects[projectIndex], projectIndex);
-            }
-        } catch (error) {
-            recordInfrastructureError(error);
-        }
-    };
     try {
-        await Promise.allSettled(Array.from({
-            length: effectiveConcurrency
-        }, ()=>worker()));
+        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;
+            }
+        });
+    } catch (error) {
+        recordInfrastructureError(error);
     } finally{
         process.off('SIGINT', sigint);
         process.off('SIGTERM', sigterm);
     }
-    if (hasInfrastructureError) throw firstInfrastructureError;
     const completedProjectResults = preparedProjects.map((prepared, projectIndex)=>{
         const result = projectResults[projectIndex];
         if (result) return result;
@@ -2413,7 +1215,7 @@ async function runTestProject(options = {}) {
         return buildSkippedProjectResult(prepared, projectIndex, reason);
     });
     const summary = summarize(completedProjectResults);
-    const failed = rootController.signal.aborted || summary.failed > 0 || summary.notRun > 0 || summary.collectionErrors > 0 || summary.documentFailures > 0 || summary.projectFailures > 0;
+    const failed = hasInfrastructureError || rootController.signal.aborted || summary.failed > 0 || summary.notRun > 0 || summary.collectionErrors > 0 || summary.documentFailures > 0 || summary.projectFailures > 0;
     const endedAt = new Date();
     const result = {
         schemaVersion: 3,
@@ -2430,34 +1232,66 @@ async function runTestProject(options = {}) {
         projects: completedProjectResults,
         cases: completedProjectResults.flatMap((project)=>project.cases),
         documents: completedProjectResults.flatMap((project)=>project.documents),
-        collectionErrors: completedProjectResults.flatMap((project)=>project.collectionErrors)
+        collectionErrors: completedProjectResults.flatMap((project)=>project.collectionErrors),
+        ...hasInfrastructureError ? {
+            errors: infrastructureErrors.map(asExecutionError)
+        } : {}
     };
-    writeTestProjectRunResult({
-        projectRoot,
-        ...configPath ? {
-            configPath
-        } : {},
-        result
-    });
-    const reportPath = new TestRunReportAssembler().assemble({
-        outputDir: reportDir,
-        reportFileName: `test-run-${runId}`,
-        sources: collectTestRunReportSources(result),
-        buildRunnerDump: (index)=>buildTestRunReportDump(result, index)
-    });
-    const completedResult = {
-        ...result,
-        reportPath
+    let completedResult = result;
+    const publish = async (operation, path, callback)=>{
+        try {
+            await callback();
+            return true;
+        } catch (error) {
+            recordInfrastructureError(error instanceof WorkflowPublicationError || error instanceof WorkflowExecutionFailure ? error : new WorkflowPublicationError(operation, path, error));
+            completedResult = {
+                ...completedResult,
+                status: 'failed',
+                exitCode: 1,
+                errors: infrastructureErrors.map(asExecutionError)
+            };
+            return false;
+        }
     };
-    writeTestProjectRunResult({
-        projectRoot,
-        ...configPath ? {
-            configPath
-        } : {},
-        result: completedResult
+    const writeSummary = ()=>publish('write-result', summaryPath, ()=>writeTestProjectRunResult({
+                projectRoot,
+                ...configPath ? {
+                    configPath
+                } : {},
+                result: completedResult
+            }));
+    const writeReport = ()=>publish('write-report', reportDir, async ()=>{
+            if (!plan.reportEnabled) return;
+            const reportPath = await new TestRunReportAssembler().assembleAsync({
+                outputDir: reportDir,
+                reportFileName: `midscene-e2e-${runId}`,
+                overwrite: false,
+                sources: collectTestRunReportSources(completedResult),
+                buildRunnerDump: (index)=>{
+                    const dump = buildTestRunReportDump(completedResult, index);
+                    const warn = getDebug('test-runner:report-assembler', {
+                        console: true
+                    });
+                    for (const diagnostic of dump.diagnostics ?? [])warn(diagnostic.message);
+                    return dump;
+                }
+            });
+            completedResult = {
+                ...completedResult,
+                reportPath
+            };
+        });
+    await writeReport();
+    for (const publication of plan.publications)await publish(publication.operation, publication.path, async ()=>{
+        await publication.publish(completedResult);
     });
+    await writeSummary();
+    if (hasInfrastructureError) throw new WorkflowExecutionFailure(completedResult, infrastructureErrors);
     return completedResult;
 }
+async function runTestProject(options = {}) {
+    return runPreparedTestProject(await prepareTestRun(options));
+}
 export { DEFAULT_TEST_FILE_SELECTION, createTestRunId, defineProjectSetup, defineTestProject, discoverTestConfig, discoverTestFiles, loadTestProject, runTestProject, validateTestFileSelection };
 
 //# sourceMappingURL=index.mjs.map