@midscene/test 1.15.2-beta-20261012123219.0 → 1.15.2

package/dist/lib/cli/index.js

@@ -318,7 +318,6 @@ async function loadTestProject(configPath) {
 }
 const external_node_fs_namespaceObject = require("node:fs");
 const external_tinyglobby_namespaceObject = require("tinyglobby");
-const external_js_yaml_namespaceObject = require("js-yaml");
 const external_node_crypto_namespaceObject = require("node:crypto");
 const createCaseInvocationId = (projectId, sourcePath, caseIndex, invocationIndex = 0)=>(0, external_node_crypto_namespaceObject.createHash)('sha256').update(JSON.stringify([
         projectId,
@@ -336,6 +335,70 @@ const createDocumentInvocationId = (projectId, sourcePath, invocationIndex = 0)=
         ] : []
     ])).digest('hex');
 const normalizeSteps = test_runner_namespaceObject.normalizeSteps;
+const external_js_yaml_namespaceObject = require("js-yaml");
+function parseWorkflowSource(source) {
+    const stack = [];
+    const nodes = [];
+    const sensitiveNodes = new Set();
+    const sensitiveValues = new Set();
+    const redactedPaths = new Set();
+    const sourceOffset = 0xfeff === source.charCodeAt(0) ? 1 : 0;
+    const parsed = (0, external_js_yaml_namespaceObject.load)(source, {
+        schema: external_js_yaml_namespaceObject.JSON_SCHEMA,
+        listener (event, state) {
+            if ('open' === event) return void stack.push({
+                start: state.position + sourceOffset,
+                end: 0,
+                value: null,
+                children: []
+            });
+            const node = stack.pop();
+            node.end = state.position + sourceOffset;
+            node.value = state.result;
+            stack.at(-1)?.children.push(node);
+            nodes.push(node);
+            if ('mapping' !== state.kind) return;
+            for(let index = 0; index < node.children.length; index += 2){
+                const key = node.children[index].value;
+                const value = node.children[index + 1];
+                if ('string' == typeof key && (0, test_runner_namespaceObject.isReportSecretKey)(key) && value) {
+                    sensitiveNodes.add(value);
+                    if (null !== value.value) sensitiveValues.add(value.value);
+                    redactedPaths.add(`$..[${JSON.stringify(key)}]`);
+                }
+            }
+        }
+    });
+    const ranges = nodes.filter((node)=>sensitiveNodes.has(node) || sensitiveValues.has(node.value)).sort((left, right)=>left.start - right.start || right.end - left.end);
+    let offset = 0;
+    let redacted = '';
+    for (const range of ranges){
+        if (range.start < offset) continue;
+        const text = source.slice(range.start, range.end);
+        const leading = text.match(/^\s*/)?.[0] ?? '';
+        const trailing = text.slice(leading.length).match(/\s*$/)?.[0] ?? '';
+        redacted += `${source.slice(offset, range.start)}${leading}"[REDACTED]"${trailing}`;
+        offset = range.end;
+    }
+    redacted += source.slice(offset);
+    const value = (0, test_runner_namespaceObject.sanitizeReportText)(redacted, 65536);
+    return {
+        parsed,
+        sourceYaml: {
+            value,
+            ...redactedPaths.size ? {
+                redactedPaths: [
+                    ...redactedPaths
+                ]
+            } : {},
+            ...value !== redacted ? {
+                truncatedPaths: [
+                    '$'
+                ]
+            } : {}
+        }
+    };
+}
 const interpolationExpression = /\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}|\$\{([^{}]+)\}/g;
 const exactEnvExpression = /^\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/;
 const exactProjectExpression = /^\$\{([^{}]+)\}$/;
@@ -410,16 +473,15 @@ const collect_rejectUnknownKeys = (value, allowed, label)=>{
 const createCaseId = (projectId, sourcePath, caseIndex)=>createCaseInvocationId(projectId, sourcePath, caseIndex);
 const createWorkflowDocumentId = (projectId, sourcePath)=>createDocumentInvocationId(projectId, sourcePath);
 function collectWorkflowDocument(source, options) {
-    let parsed;
+    let snapshot;
     try {
-        parsed = (0, external_js_yaml_namespaceObject.load)((0, external_node_fs_namespaceObject.readFileSync)(source.absolutePath, 'utf8'), {
-            schema: external_js_yaml_namespaceObject.JSON_SCHEMA
-        });
+        snapshot = parseWorkflowSource((0, external_node_fs_namespaceObject.readFileSync)(source.absolutePath, 'utf8'));
     } catch (error) {
         throw new test_runner_namespaceObject.WorkflowParseError(`Failed to parse workflow document "${source.sourcePath}".`, {
             sourcePath: source.sourcePath
         }, error);
     }
+    const { parsed, sourceYaml } = snapshot;
     if (!isMapping(parsed)) throw new test_runner_namespaceObject.WorkflowParseError('Workflow document must be a mapping.');
     const format = (0, test_runner_namespaceObject.classifyWorkflowDocumentFormat)(parsed);
     if ('legacy' === format || 'legacy-batch' === format || 'mixed' === format) throw new NativeWorkflowFormatError(format, source.sourcePath);
@@ -434,6 +496,7 @@ function collectWorkflowDocument(source, options) {
     const sourcePath = source.sourcePath.split(external_node_path_namespaceObject.sep).join('/');
     const resolveStepVariables = (step, phase, stepIndex, caseIndex)=>({
             ...step,
+            templateInput: step.input,
             input: resolveWorkflowVariables(step.input, {
                 variables: options.variables,
                 env: options.env ?? process.env,
@@ -519,6 +582,7 @@ function collectWorkflowDocument(source, options) {
         documentId: createWorkflowDocumentId(source.projectId, sourcePath),
         projectId: source.projectId,
         sourcePath,
+        sourceYaml,
         lifecycle,
         cases
     };
@@ -534,6 +598,15 @@ const writeJson = async (path, value)=>{
         throw new test_runner_namespaceObject.WorkflowPublicationError('write-result', path, error);
     }
 };
+const writeTestRunPlan = (runDir, projects)=>writeJson((0, external_node_path_namespaceObject.join)(runDir, 'plan.json'), {
+        schemaVersion: 1,
+        createdAt: new Date().toISOString(),
+        projects: projects.map((item)=>({
+                projectId: item.project.projectId,
+                name: item.project.name,
+                documents: item.plans ?? []
+            }))
+    });
 const toPosix = (value)=>value.split(external_node_path_namespaceObject.sep).join('/');
 const caseAttemptResultPath = (projectId, documentId, result)=>toPosix((0, external_node_path_namespaceObject.join)(projectId, 'documents', documentId, 'cases', result.caseId, `${result.runId}.json`));
 const workflowDocumentResultPath = (result)=>toPosix((0, external_node_path_namespaceObject.join)(result.projectId, 'documents', result.documentId, void 0 === result.attemptIndex ? 'document.json' : `${result.documentRunId}.json`));
@@ -563,7 +636,7 @@ const relativeToSummary = (summaryPath, target)=>{
     const value = (0, external_node_path_namespaceObject.relative)((0, external_node_path_namespaceObject.dirname)(summaryPath), target);
     return toPosix(value || '.');
 };
-const errorJson = (error)=>error instanceof Error && 'toJSON' in error ? error.toJSON() : error;
+const errorJson = test_runner_namespaceObject.sanitizeReportError;
 const writeTestProjectRunResult = (options)=>{
     const { result } = options;
     const fact = (path)=>toPosix(path);
@@ -583,13 +656,17 @@ const writeTestProjectRunResult = (options)=>{
             configPath: options.configPath
         } : {},
         factsRoot: '.',
+        plan: 'plan.json',
+        ...result.operationLog ? {
+            operationLog: {
+                ...result.operationLog,
+                path: relativeToSummary(result.summaryPath, result.operationLog.path)
+            }
+        } : {},
         reportDir: relativeToSummary(result.summaryPath, result.reportDir),
         ...result.reportPath ? {
             report: relativeToSummary(result.summaryPath, result.reportPath)
         } : {},
-        ...result.markdownPath ? {
-            markdown: relativeToSummary(result.summaryPath, result.markdownPath)
-        } : {},
         summary: result.summary,
         projects: result.projects.map((project)=>({
                 projectId: project.projectId,
@@ -607,6 +684,12 @@ const writeTestProjectRunResult = (options)=>{
                         startedAt: project.lifecycle.startedAt,
                         endedAt: project.lifecycle.endedAt,
                         durationMs: project.lifecycle.durationMs,
+                        ...project.lifecycle.cleanup ? {
+                            cleanup: project.lifecycle.cleanup
+                        } : {},
+                        ...project.lifecycle.pendingOperations ? {
+                            pendingOperations: project.lifecycle.pendingOperations
+                        } : {},
                         ...project.lifecycle.setupError ? {
                             setupError: errorJson(project.lifecycle.setupError)
                         } : {},
@@ -633,6 +716,18 @@ const writeTestProjectRunResult = (options)=>{
                                     attemptId: attempt.runId,
                                     attemptIndex: attempt.attemptIndex,
                                     status: attempt.status,
+                                    ...attempt.cleanup ? {
+                                        cleanup: attempt.cleanup
+                                    } : {},
+                                    ...attempt.pendingOperations ? {
+                                        pendingOperations: attempt.pendingOperations
+                                    } : {},
+                                    ...attempt.executionStatus ? {
+                                        executionStatus: attempt.executionStatus
+                                    } : {},
+                                    ...attempt.retryDecision ? {
+                                        retryDecision: attempt.retryDecision
+                                    } : {},
                                     resultFile: fact(caseAttemptResultPath(project.projectId, outcome.documentId, attempt)),
                                     ...attempt.reportPaths?.length ? {
                                         reports: attempt.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
@@ -648,6 +743,18 @@ const writeTestProjectRunResult = (options)=>{
                         },
                         sourcePath: document.sourcePath,
                         status: document.status,
+                        ...document.cleanup ? {
+                            cleanup: document.cleanup
+                        } : {},
+                        ...document.pendingOperations ? {
+                            pendingOperations: document.pendingOperations
+                        } : {},
+                        ...document.executionStatus ? {
+                            executionStatus: document.executionStatus
+                        } : {},
+                        ...document.retryDecision ? {
+                            retryDecision: document.retryDecision
+                        } : {},
                         resultFile: fact(workflowDocumentResultPath(document)),
                         ...document.reportPaths?.length ? {
                             reports: document.reportPaths.map((path)=>relativeToSummary(result.summaryPath, path))
@@ -787,6 +894,7 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
     });
     const collectionErrors = [];
     const invocations = [];
+    const plans = [];
     let filteredCaseCount = 0;
     if (0 === sources.length) {
         const error = asCollectionError(project.projectId, project.name, '<project>', new test_runner_namespaceObject.WorkflowParseError(`No workflow YAML files found for project "${project.name}" in ${projectRoot}.`, {
@@ -800,7 +908,17 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
         const collected = await options.collectDocument?.(source, project);
         if (collected) {
             filteredCaseCount += collected.filteredCaseCount;
-            if (collected.invocation) invocations.push(collected.invocation);
+            if (collected.invocation) {
+                const plan = (0, test_runner_namespaceObject.buildTestRunReportPlan)(collected.invocation.document, {
+                    defaultTimeoutMs: collected.invocation.defaultTimeoutMs,
+                    retry: collected.invocation.retry
+                });
+                invocations.push({
+                    ...collected.invocation,
+                    plan
+                });
+                plans.push(plan);
+            }
             continue;
         }
         const document = collectWorkflowDocument(source, {
@@ -812,8 +930,18 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
             document,
             filtered: 0
         } : filterDocumentCases(document, project);
+        const plan = (0, test_runner_namespaceObject.buildTestRunReportPlan)(document, {
+            selectedCaseIds: filtered.document?.cases.map((item)=>item.caseId) ?? [],
+            defaultTimeoutMs,
+            retry: {
+                scope: 'case',
+                count: project.retry
+            }
+        });
+        plans.push(plan);
         filteredCaseCount += filtered.filtered;
         if (filtered.document) invocations.push({
+            plan,
             document: filtered.document,
             retry: {
                 scope: 'case',
@@ -846,6 +974,7 @@ async function prepareProject(project, projectRoot, runDir, defaultTimeoutMs, op
         sources,
         documents,
         invocations,
+        plans,
         collectionErrors,
         selectedCaseCount: documents.reduce((total, document)=>total + document.cases.length, 0),
         filteredCaseCount
@@ -929,103 +1058,6 @@ async function prepareTestRun(options) {
 const external_node_events_namespaceObject = require("node:events");
 const report_namespaceObject = require("@midscene/core/report");
 const logger_namespaceObject = require("@midscene/shared/logger");
-const result_markdown_text = (value)=>value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll('|', '&#124;').replaceAll('[', '&#91;').replaceAll(']', '&#93;').replaceAll('*', '&#42;').replaceAll('_', '&#95;').replaceAll('`', '&#96;').replaceAll('\\', '&#92;').replace(/[\r\n]+/g, ' ');
-const duration = (ms)=>{
-    const seconds = Math.round(ms / 1000);
-    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-};
-const href = (from, target)=>(0, external_node_path_namespaceObject.relative)((0, external_node_path_namespaceObject.dirname)(from), target).split(external_node_path_namespaceObject.sep).map(encodeURIComponent).join('/');
-function renderTestResultMarkdown(dump, options = {}) {
-    const { summary } = dump;
-    const outcome = 'success' === dump.status ? `✅ **${summary.passed}/${summary.total} passed**` : `❌ **${summary.failed} failed** · ${summary.passed} passed · ${summary.notRun} not run`;
-    const lines = [
-        '## Midscene Test',
-        '',
-        `${outcome} · ${duration(dump.durationMs)}`,
-        ''
-    ];
-    if (summary.filtered) lines.push(`**Filtered:** ${summary.filtered}`, '');
-    const infrastructure = [
-        summary.collectionErrors ? `${summary.collectionErrors} collection errors` : '',
-        summary.documentFailures ? `${summary.documentFailures} document failures` : '',
-        summary.projectFailures ? `${summary.projectFailures} project failures` : ''
-    ].filter(Boolean);
-    if (infrastructure.length) lines.push(`**Infrastructure:** ${infrastructure.join(' · ')}`, '');
-    const groups = [];
-    const errors = [];
-    const recordSteps = (label, steps)=>{
-        for (const step of steps)if ('failed' === step.status) errors.push(`${label} / ${step.node}: ${step.error?.message ?? 'Step failed'}`);
-    };
-    for (const project of dump.projects){
-        if (project.lifecycle?.setupError) errors.push(`${project.name}: ${project.lifecycle.setupError.message}`);
-        for (const error of project.lifecycle?.teardownErrors ?? [])errors.push(`${project.name}: ${error.message}`);
-        for (const error of project.collectionErrors)errors.push(`${project.name} / ${error.sourcePath}: ${error.error.message}`);
-        for (const document of project.documents){
-            const name = document.sourcePath.replace(/\\/g, '/').replace(/\.(?:yaml|yml)$/, '');
-            const group = {
-                name: dump.projects.length > 1 ? `${project.name} / ${name}` : name,
-                rows: []
-            };
-            groups.push(group);
-            recordSteps(`${project.name} / ${document.sourcePath}`, [
-                ...document.beforeAll,
-                ...document.afterAll
-            ]);
-            for (const error of document.teardownErrors ?? [])errors.push(`${document.sourcePath}: ${error.message}`);
-            for (const failure of document.hostErrors ?? [])errors.push(`${document.sourcePath} / ${failure.phase}: ${failure.error.message}`);
-            for (const testCase of document.cases){
-                const attempt = testCase.attempts.at(-1);
-                const steps = attempt ? [
-                    ...attempt.beforeEach,
-                    ...attempt.steps,
-                    ...attempt.afterEach
-                ] : [];
-                const failedSteps = steps.filter((step)=>'failed' === step.status);
-                const step = failedSteps.at(-1) ?? [
-                    ...steps
-                ].reverse().find((item)=>item.agentDetails?.length) ?? steps.at(-1);
-                const route = new URLSearchParams({
-                    'runner-page': 'case',
-                    'runner-project': project.projectId,
-                    'runner-case': testCase.caseId,
-                    ...step ? {
-                        'runner-step': step.id
-                    } : {}
-                });
-                const target = options.reportHref ? `${options.reportHref}#${route}` : void 0;
-                const name = target ? `[${result_markdown_text(testCase.name)}](<${target}>)` : result_markdown_text(testCase.name);
-                group.rows.push(`  - ${'success' === testCase.status ? '✅' : 'not-run' === testCase.status ? '⏭️' : '❌'} ${name}`);
-            }
-        }
-    }
-    for (const diagnostic of dump.diagnostics ?? [])if ('error' === diagnostic.level) errors.push(diagnostic.message);
-    if (errors.length) lines.push('### Execution errors', '', ...errors.map((error)=>`- ${result_markdown_text(error)}`), '');
-    for (const group of groups)if (group.rows.length) lines.push(`- ${result_markdown_text(group.name)}`, ...group.rows);
-    if (!groups.some((group)=>group.rows.length)) lines.push('No cases were reported.');
-    if (options.reportHref) lines.push('', `[Open the Midscene Test report ↗](<${options.reportHref}>)`);
-    return `${lines.join('\n')}\n`;
-}
-const emptyIndex = ()=>({
-        sources: [],
-        metrics: {
-            modelCallCount: 0,
-            modelTimeMs: 0,
-            promptTokens: 0,
-            cachedInputTokens: 0,
-            completionTokens: 0,
-            totalTokens: 0
-        }
-    });
-async function writeTestResultMarkdown(result, index = emptyIndex()) {
-    const output = (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(result.summaryPath), 'result.md');
-    const dump = (0, test_runner_namespaceObject.buildTestRunReportDump)(result, index);
-    await (0, promises_namespaceObject.writeFile)(output, renderTestResultMarkdown(dump, {
-        ...result.reportPath ? {
-            reportHref: href(output, result.reportPath)
-        } : {}
-    }));
-    return output;
-}
 const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
 const formatStep = (info)=>{
     const position = stepPosition(info);
@@ -1034,6 +1066,7 @@ const formatStep = (info)=>{
 };
 const formatStepResult = (info, result)=>{
     const indent = 'case' === info.scope ? '      ' : '    ';
+    if ('not-run' === result.status) return `${indent}– ${formatStep(info)} (not run: ${result.notRunReason})`;
     const symbol = 'success' === result.status ? '✓' : '✗';
     const error = result.error ? ` — ${result.error.message}` : '';
     const continuation = result.continuedAfterError ? '; continuing' : '';
@@ -1043,11 +1076,11 @@ const caseHasFatalError = (outcome)=>(outcome.attempts ?? []).some((attempt)=>[
             ...attempt.beforeEach,
             ...attempt.steps,
             ...attempt.afterEach
-        ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (attempt.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError));
+        ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (attempt.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError) || !!attempt.executionErrors?.some(test_runner_namespaceObject.isResourceRecoveryError));
 const documentHasFatalError = (result)=>[
         ...result.beforeAll,
         ...result.afterAll
-    ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (result.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError);
+    ].some((step)=>step.error && (0, test_runner_namespaceObject.isFatalDeviceError)(step.error)) || (result.teardownErrors ?? []).some(test_runner_namespaceObject.isFatalDeviceError) || !!result.executionErrors?.some(test_runner_namespaceObject.isResourceRecoveryError);
 async function executeDocumentInvocation(options) {
     const { invocation, project, sinks } = options;
     const { document } = invocation;
@@ -1060,6 +1093,7 @@ async function executeDocumentInvocation(options) {
     }, async (documentAttemptIndex)=>{
         if (documentRetry) options.onProgress(`    file attempt ${documentAttemptIndex + 1}/${invocation.retry.count + 1}: ${document.sourcePath}`);
         const execution = await (0, test_runner_namespaceObject.runWorkflowDocument)(document, {
+            plan: invocation.plan,
             documentAttemptIndex: documentRetry ? documentAttemptIndex : void 0,
             ...invocation.bindings,
             project,
@@ -1097,6 +1131,18 @@ async function executeDocumentInvocation(options) {
         }).catch(async (error)=>{
             if (error instanceof test_runner_namespaceObject.WorkflowExecutionFailure) {
                 const partial = error.result;
+                const resourceOnly = error.errors.length > 0 && error.errors.every((failure)=>(0, test_runner_namespaceObject.isResourceRecoveryError)(failure) || partial.document.hostErrors?.some((host)=>'cleanup' === host.phase && (host.error === failure || host.error instanceof Error && host.error.cause === failure)));
+                if (resourceOnly) {
+                    if (error.errors.some(test_runner_namespaceObject.isResourceRecoveryError)) options.markProjectFatal();
+                    return partial;
+                }
+                if (documentRetry) partial.document.retryDecision = (0, test_runner_namespaceObject.decideRetry)({
+                    scope: 'document',
+                    retryCount: invocation.retry.count,
+                    attemptIndex: documentAttemptIndex,
+                    status: 'failed',
+                    infrastructureError: true
+                });
                 attempts.push(partial);
                 sinks.documents.push(partial.document);
                 sinks.cases.push(...partial.cases.map((outcome)=>({
@@ -1105,6 +1151,7 @@ async function executeDocumentInvocation(options) {
                         documentRunId: partial.document.documentRunId
                     })));
                 try {
+                    for (const outcome of partial.cases)for (const attempt of outcome.attempts ?? [])await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
                     await writeWorkflowDocumentResult(options.runDir, partial.document);
                 } catch (publicationError) {
                     throw new test_runner_namespaceObject.WorkflowExecutionFailure(partial, [
@@ -1115,6 +1162,29 @@ async function executeDocumentInvocation(options) {
             }
             throw error;
         });
+        if (documentHasFatalError(execution.document)) options.markProjectFatal();
+        const owners = [
+            execution.document,
+            ...execution.cases.flatMap((outcome)=>outcome.attempts ?? [])
+        ];
+        const cleanupPending = owners.some((owner)=>owner.cleanup?.status === 'pending');
+        const operationPending = owners.some((owner)=>!!owner.pendingOperations?.length);
+        const cleanupFailed = owners.some((owner)=>owner.cleanup?.status === 'failed' || !!owner.teardownErrors?.length || 'hostErrors' in owner && owner.hostErrors?.some(({ phase })=>'cleanup' === phase));
+        if (cleanupPending || cleanupFailed || operationPending) options.markProjectFatal();
+        const failed = 'failed' === execution.document.status || execution.cases.some((item)=>'success' !== item.status);
+        const decision = (0, test_runner_namespaceObject.decideRetry)({
+            scope: 'document',
+            retryCount: invocation.retry.count,
+            attemptIndex: documentAttemptIndex,
+            status: failed ? 'failed' : 'success',
+            cleanupPending,
+            cleanupFailed,
+            operationPending,
+            fatalError: options.isProjectFatal(),
+            interrupted: options.signal.aborted || options.rootSignal.aborted,
+            shouldStop: options.shouldBail()
+        });
+        if (documentRetry) execution.document.retryDecision = decision;
         attempts.push(execution);
         sinks.cases.push(...execution.cases.map((outcome)=>({
                 ...outcome,
@@ -1122,15 +1192,30 @@ async function executeDocumentInvocation(options) {
                 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 test_runner_namespaceObject.WorkflowExecutionFailure(execution, cleanupErrors);
-        const failed = 'failed' === execution.document.status || execution.cases.some((item)=>'success' !== item.status);
-        return failed ? 'failed' : 'success';
+        try {
+            for (const outcome of execution.cases)for (const attempt of outcome.attempts ?? [])await writeCaseAttemptResult(options.runDir, project.projectId, document.documentId, attempt);
+            await writeWorkflowDocumentResult(options.runDir, execution.document);
+        } catch (error) {
+            execution.document.status = 'failed';
+            execution.document.hostErrors = [
+                ...execution.document.hostErrors ?? [],
+                {
+                    phase: 'publication',
+                    error
+                }
+            ];
+            if (documentRetry) execution.document.retryDecision = (0, test_runner_namespaceObject.decideRetry)({
+                scope: 'document',
+                retryCount: invocation.retry.count,
+                attemptIndex: documentAttemptIndex,
+                status: 'failed',
+                infrastructureError: true
+            });
+            throw new test_runner_namespaceObject.WorkflowExecutionFailure(execution, [
+                error
+            ]);
+        }
+        return 'retry' === decision.decision ? 'failed' : void 0;
     });
     const final = attempts.at(-1);
     if (!final) return;
@@ -1138,6 +1223,18 @@ async function executeDocumentInvocation(options) {
     if (documentRetry && failedCases) options.addFailedCases(failedCases);
     else if ('failed' === final.document.status && 0 === failedCases) options.addFailedCases(Math.max(1, failedCases));
 }
+function createOperationJournal(runDir) {
+    const path = (0, external_node_path_namespaceObject.join)(runDir, 'operations.jsonl');
+    (0, external_node_fs_namespaceObject.writeFileSync)(path, '', {
+        flag: 'wx'
+    });
+    return {
+        path,
+        append (event) {
+            (0, external_node_fs_namespaceObject.appendFileSync)(path, `${JSON.stringify(event)}\n`);
+        }
+    };
+}
 const asNotRun = (documentId, collectedCase, projectName, reason)=>({
         documentId,
         caseId: collectedCase.caseId,
@@ -1196,6 +1293,8 @@ async function runPreparedTestProject(plan) {
     const totalErrors = preparedProjects.reduce((total, prepared)=>total + prepared.collectionErrors.length, 0);
     progress(`midscene-test: preflighted ${preparedProjects.length} projects, ${totalDocuments} documents, ${totalCases} cases, ${totalErrors} collection errors`);
     const effectiveConcurrency = Math.min(definition.test.maxConcurrency, preparedProjects.length);
+    await writeTestRunPlan(runDir, preparedProjects);
+    const journal = createOperationJournal(runDir);
     const rootController = new AbortController();
     (0, external_node_events_namespaceObject.setMaxListeners)(Math.max(10, effectiveConcurrency + 1), rootController.signal);
     const handleSignal = (signal)=>{
@@ -1225,6 +1324,16 @@ async function runPreparedTestProject(plan) {
             throw error;
         }
     };
+    const stopObservingOperations = (0, test_runner_namespaceObject.observeResourceOperations)(rootController.signal, (event)=>{
+        try {
+            journal.append(event);
+        } catch (error) {
+            recordInfrastructureError(new test_runner_namespaceObject.WorkflowPublicationError('write-result', journal.path, error));
+            (0, logger_namespaceObject.getDebug)('test-runner:operations', {
+                console: true
+            })(`Could not persist operation event: ${String(error)}`);
+        }
+    });
     const announceProject = (prepared, projectIndex)=>{
         const { project } = prepared;
         runInfrastructureCallback(()=>progress(`[project ${projectIndex + 1}/${preparedProjects.length}] ${project.name}`));
@@ -1249,6 +1358,7 @@ async function runPreparedTestProject(plan) {
                 lifecycle
             } : {},
             cases,
+            plans: prepared.plans,
             documents,
             collectionErrors: prepared.collectionErrors
         };
@@ -1367,6 +1477,7 @@ async function runPreparedTestProject(plan) {
     } catch (error) {
         recordInfrastructureError(error);
     } finally{
+        stopObservingOperations();
         process.off('SIGINT', sigint);
         process.off('SIGTERM', sigterm);
     }
@@ -1382,6 +1493,10 @@ async function runPreparedTestProject(plan) {
     const endedAt = new Date();
     const result = {
         schemaVersion: 3,
+        operationLog: {
+            path: journal.path,
+            snapshotAt: endedAt.toISOString()
+        },
         runId,
         startedAt: startedAt.toISOString(),
         endedAt: endedAt.toISOString(),
@@ -1401,7 +1516,6 @@ async function runPreparedTestProject(plan) {
         } : {}
     };
     let completedResult = result;
-    let reportIndex;
     const publish = async (operation, path, callback)=>{
         try {
             await callback();
@@ -1432,7 +1546,6 @@ async function runPreparedTestProject(plan) {
                 overwrite: false,
                 sources: (0, test_runner_namespaceObject.collectTestRunReportSources)(completedResult),
                 buildRunnerDump: (index)=>{
-                    reportIndex = index;
                     const dump = (0, test_runner_namespaceObject.buildTestRunReportDump)(completedResult, index);
                     const warn = (0, logger_namespaceObject.getDebug)('test-runner:report-assembler', {
                         console: true
@@ -1450,13 +1563,6 @@ async function runPreparedTestProject(plan) {
     for (const publication of plan.publications)await publish(publication.operation, publication.path, async ()=>{
         await publication.publish(completedResult);
     });
-    await publish('write-result', (0, external_node_path_namespaceObject.join)((0, external_node_path_namespaceObject.dirname)(summaryPath), 'result.md'), async ()=>{
-        const markdownPath = await writeTestResultMarkdown(completedResult, reportIndex);
-        completedResult = {
-            ...completedResult,
-            markdownPath
-        };
-    });
     await writeSummary();
     if (hasInfrastructureError) throw new test_runner_namespaceObject.WorkflowExecutionFailure(completedResult, infrastructureErrors);
     return completedResult;