@windsland52/maa-log-tools 1.3.0 → 2.0.0

package/README.md

@@ -87,7 +87,9 @@ process-start-bounded interval contains the timestamp; otherwise it returns `nul
 `mla-runtime-inspection/v1`. It nests task executions under their runtime session and keeps three
 different semantics separate:
 
-- `failures`: direct `next_list_timeout` and `action_failed` facts.
+- `failures`: directly observed `next_list_timeout` and `action_failed` facts, including failures
+  inside tasks launched by custom actions. Nested failures retain the nested task identity and
+  images while sharing the enclosing top-level `executionId`.
 - `outcomes`: failed or still-running pipeline nodes and tasks, with direct-failure references
   when the propagation can be linked deterministically.
 - `signals`: useful non-failure behavior such as recognition succeeding after earlier misses and
@@ -97,6 +99,10 @@ An unsuccessful recognition attempt is retry telemetry, not a failure. A next-li
 reported only when the node finishes without matching a candidate. Repeated recognition attempts
 inside one node are not treated as pipeline loops.
 
+`RuntimeTaskExecution.directFailureIds` and its failure statistics remain limited to the
+top-level task's own pipeline nodes. Nested task failures are available through `failures` and
+`outcomes`, so a propagated parent action failure and its underlying nested failure stay distinct.
+
 Tasks are assigned to a process-start session by timestamp. A file segment without a
 `MAA Process Start` marker can also contain tasks when it is the only matching partial interval;
 ambiguous tasks remain in `unscopedTasks` and produce a warning.

package/dist/archiveLimits.d.ts

@@ -2,7 +2,6 @@ import { type Unzipped } from 'fflate';
 export interface ArchiveLimits {
     maxVolumes: number;
     maxCompressedBytes: number;
-    maxEntries: number;
     maxPathBytes: number;
     maxTotalPathBytes: number;
     maxFileBytes: number;
@@ -11,7 +10,7 @@ export interface ArchiveLimits {
     maxCompressionRatio: number;
     compressionRatioMinBytes: number;
 }
-export type ArchiveLimitCode = 'volume-count' | 'compressed-size' | 'entry-count' | 'path-size' | 'total-path-size' | 'file-size' | 'image-size' | 'extracted-size' | 'compression-ratio';
+export type ArchiveLimitCode = 'volume-count' | 'compressed-size' | 'path-size' | 'total-path-size' | 'file-size' | 'image-size' | 'extracted-size' | 'compression-ratio';
 export declare class ArchiveLimitError extends Error {
     readonly code: ArchiveLimitCode;
     readonly actual: number;
@@ -33,7 +32,6 @@ export interface ArchiveEntryMetadata {
     compression: number;
 }
 export interface ArchiveDirectoryBudget {
-    entryCount: number;
     totalPathBytes: number;
 }
 export interface ExtractionBudget {

package/dist/archiveLimits.js

@@ -21,7 +21,6 @@ export class ArchiveFormatError extends Error {
 export const DEFAULT_ARCHIVE_LIMITS = Object.freeze({
     maxVolumes: 16,
     maxCompressedBytes: 268435456,
-    maxEntries: 10000,
     maxPathBytes: 4096,
     maxTotalPathBytes: 8388608,
     maxFileBytes: 268435456,
@@ -33,7 +32,6 @@ export const DEFAULT_ARCHIVE_LIMITS = Object.freeze({
 const integerLimitKeys = [
     'maxVolumes',
     'maxCompressedBytes',
-    'maxEntries',
     'maxPathBytes',
     'maxTotalPathBytes',
     'maxFileBytes',
@@ -58,7 +56,6 @@ export const resolveArchiveLimits = (overrides = {}) => validateLimits({
     ...overrides,
 });
 export const EMPTY_ARCHIVE_DIRECTORY_BUDGET = Object.freeze({
-    entryCount: 0,
     totalPathBytes: 0,
 });
 export const EMPTY_EXTRACTION_BUDGET = Object.freeze({
@@ -111,13 +108,13 @@ const canonicalizeArchivePath = (rawPath) => {
     }
     const segments = canonical.split('/');
     for (const [index, segment] of segments.entries()) {
-        if (segment.length === 0
-            || segment === '.'
-            || segment === '..'
-            || segment.endsWith('.')
-            || segment.endsWith(' ')
-            || segment.includes(':')
-            || (index === 0 && /^[a-z]:$/iu.test(segment))) {
+        if (segment.length === 0 ||
+            segment === '.' ||
+            segment === '..' ||
+            segment.endsWith('.') ||
+            segment.endsWith(' ') ||
+            segment.includes(':') ||
+            (index === 0 && /^[a-z]:$/iu.test(segment))) {
             throwFormatError('invalid-path', rawPath, `Archive entry uses a path alias: ${rawPath}`);
         }
     }
@@ -133,10 +130,6 @@ export const addArchiveDirectoryEntry = (current, entry, limits = DEFAULT_ARCHIV
     assertMetadataInteger(entry.size, 'compressed entry size');
     assertMetadataInteger(entry.originalSize, 'original entry size');
     assertMetadataInteger(entry.compression, 'compression method');
-    const entryCount = addSize(current.entryCount, 1, 'entry count');
-    if (entryCount > limits.maxEntries) {
-        throwLimitError('entry-count', entryCount, limits.maxEntries);
-    }
     const pathBytes = utf8Encoder.encode(entry.name).byteLength;
     if (pathBytes > limits.maxPathBytes) {
         throwLimitError('path-size', pathBytes, limits.maxPathBytes);
@@ -145,7 +138,7 @@ export const addArchiveDirectoryEntry = (current, entry, limits = DEFAULT_ARCHIV
     if (totalPathBytes > limits.maxTotalPathBytes) {
         throwLimitError('total-path-size', totalPathBytes, limits.maxTotalPathBytes);
     }
-    return { entryCount, totalPathBytes };
+    return { totalPathBytes };
 };
 const copyEntryMetadata = (entry) => ({
     name: entry.name,
@@ -163,10 +156,11 @@ const readU32 = (data, offset) => {
     if (offset < 0 || offset + 4 > data.byteLength) {
         throwFormatError('invalid-structure', '', 'ZIP record is truncated');
     }
-    return (data[offset]
-        | (data[offset + 1] << 8)
-        | (data[offset + 2] << 16)
-        | (data[offset + 3] << 24)) >>> 0;
+    return ((data[offset] |
+        (data[offset + 1] << 8) |
+        (data[offset + 2] << 16) |
+        (data[offset + 3] << 24)) >>>
+        0);
 };
 const findEndOfCentralDirectory = (data) => {
     const minimumOffset = Math.max(0, data.byteLength - 65557);
@@ -196,12 +190,12 @@ const parseAndValidateRawZipRecords = (data) => {
     const totalEntries = readU16(data, eocdOffset + 10);
     const centralSize = readU32(data, eocdOffset + 12);
     const centralOffset = readU32(data, eocdOffset + 16);
-    if (diskNumber !== 0
-        || centralDisk !== 0
-        || entriesOnDisk !== totalEntries
-        || totalEntries === 0xffff
-        || centralSize === 4294967295
-        || centralOffset === 4294967295) {
+    if (diskNumber !== 0 ||
+        centralDisk !== 0 ||
+        entriesOnDisk !== totalEntries ||
+        totalEntries === 0xffff ||
+        centralSize === 4294967295 ||
+        centralOffset === 4294967295) {
         throwFormatError('unsupported-archive', '', 'Multi-disk and ZIP64 archives are not supported');
     }
     if (centralOffset + centralSize !== eocdOffset) {
@@ -257,24 +251,26 @@ const parseAndValidateRawZipRecords = (data) => {
         const extraBytes = readU16(data, localOffset + 28);
         const payloadOffset = localOffset + 30 + nameBytes + extraBytes;
         const rawLocalName = data.subarray(localOffset + 30, localOffset + 30 + nameBytes);
-        if (payloadOffset > centralOffset
-            || localFlags !== entry.flags
-            || localCompression !== entry.compression
-            || !equalBytes(rawLocalName, entry.rawName)) {
+        if (payloadOffset > centralOffset ||
+            localFlags !== entry.flags ||
+            localCompression !== entry.compression ||
+            !equalBytes(rawLocalName, entry.rawName)) {
             throwFormatError('local-entry-mismatch', '', 'ZIP local and central entry declarations differ');
         }
         if ((localFlags & 1) !== 0) {
             throwFormatError('unsupported-archive', '', 'Encrypted ZIP entries are not supported');
         }
         const usesDescriptor = (localFlags & 8) !== 0;
-        if (!usesDescriptor && (localCrc32 !== entry.crc32
-            || localSize !== entry.size
-            || localOriginalSize !== entry.originalSize)) {
+        if (!usesDescriptor &&
+            (localCrc32 !== entry.crc32 ||
+                localSize !== entry.size ||
+                localOriginalSize !== entry.originalSize)) {
             throwFormatError('declared-size-mismatch', '', 'ZIP local and central sizes differ');
         }
-        if (usesDescriptor && ((localCrc32 !== 0 && localCrc32 !== entry.crc32)
-            || (localSize !== 0 && localSize !== entry.size)
-            || (localOriginalSize !== 0 && localOriginalSize !== entry.originalSize))) {
+        if (usesDescriptor &&
+            ((localCrc32 !== 0 && localCrc32 !== entry.crc32) ||
+                (localSize !== 0 && localSize !== entry.size) ||
+                (localOriginalSize !== 0 && localOriginalSize !== entry.originalSize))) {
             throwFormatError('declared-size-mismatch', '', 'ZIP streaming local sizes conflict with the central directory');
         }
         const payloadEnd = payloadOffset + entry.size;
@@ -290,9 +286,9 @@ const parseAndValidateRawZipRecords = (data) => {
             const descriptorSize = readU32(data, recordEnd + 4);
             const descriptorOriginalSize = readU32(data, recordEnd + 8);
             recordEnd += 12;
-            if (descriptorCrc32 !== entry.crc32
-                || descriptorSize !== entry.size
-                || descriptorOriginalSize !== entry.originalSize) {
+            if (descriptorCrc32 !== entry.crc32 ||
+                descriptorSize !== entry.size ||
+                descriptorOriginalSize !== entry.originalSize) {
                 throwFormatError('declared-size-mismatch', '', 'ZIP data descriptor conflicts with the central directory');
             }
         }
@@ -320,10 +316,10 @@ export const inspectZipDirectory = (data, limits = DEFAULT_ARCHIVE_LIMITS) => {
         filter: (entry) => {
             const metadata = copyEntryMetadata(entry);
             const rawEntry = rawEntries[entries.length];
-            if (!rawEntry
-                || rawEntry.size !== metadata.size
-                || rawEntry.originalSize !== metadata.originalSize
-                || rawEntry.compression !== metadata.compression) {
+            if (!rawEntry ||
+                rawEntry.size !== metadata.size ||
+                rawEntry.originalSize !== metadata.originalSize ||
+                rawEntry.compression !== metadata.compression) {
                 throwFormatError('local-entry-mismatch', metadata.name, `ZIP parsed metadata is inconsistent for ${metadata.name}`);
             }
             const archivePath = canonicalizeArchivePath(metadata.name);
@@ -357,9 +353,9 @@ export const addSelectedEntry = (current, entry, limits = DEFAULT_ARCHIVE_LIMITS
     if (extractedBytes > limits.maxExtractedBytes) {
         throwLimitError('extracted-size', extractedBytes, limits.maxExtractedBytes);
     }
-    if (checkCompressionRatio
-        && entry.originalSize >= limits.compressionRatioMinBytes
-        && entry.originalSize > 0) {
+    if (checkCompressionRatio &&
+        entry.originalSize >= limits.compressionRatioMinBytes &&
+        entry.originalSize > 0) {
         const ratio = entry.size === 0 ? Number.POSITIVE_INFINITY : entry.originalSize / entry.size;
         if (ratio > limits.maxCompressionRatio) {
             throwLimitError('compression-ratio', ratio, limits.maxCompressionRatio);
@@ -451,9 +447,7 @@ const extractSelectedEntriesStreaming = (data, entries, selectedNames, limits) =
                 abortOutput(new ArchiveLimitError('extracted-size', nextTotalSize, limits.maxExtractedBytes));
             }
             if (nextFileSize >= limits.compressionRatioMinBytes && nextFileSize > 0) {
-                const actualRatio = central.size === 0
-                    ? Number.POSITIVE_INFINITY
-                    : nextFileSize / central.size;
+                const actualRatio = central.size === 0 ? Number.POSITIVE_INFINITY : nextFileSize / central.size;
                 if (actualRatio > limits.maxCompressionRatio) {
                     abortOutput(new ArchiveLimitError('compression-ratio', actualRatio, limits.maxCompressionRatio));
                 }

package/dist/boundedFileReader.js

@@ -27,9 +27,9 @@ const assertHandleIdentity = (filePath, expected, actual) => {
     }
 };
 const assertStableContentState = (filePath, expected, actual) => {
-    if (expected.size !== actual.size
-        || expected.mtimeMs !== actual.mtimeMs
-        || expected.ctimeMs !== actual.ctimeMs) {
+    if (expected.size !== actual.size ||
+        expected.mtimeMs !== actual.mtimeMs ||
+        expected.ctimeMs !== actual.ctimeMs) {
         throw new InputFileError('content-changed', filePath, `File content or metadata changed while opening or reading: ${filePath}`);
     }
 };

package/dist/cli.js

@@ -5,7 +5,7 @@ import { pathToFileURL } from 'node:url';
 import { loadFrameworkLogSources } from './frameworkInput.js';
 import { extractFrameworkSessions, } from './frameworkVersion.js';
 import { loadNodeLogDirectory, extractZipContentFromNodeFile, readNodeTextFileContent, } from './nodeInput.js';
-import { analyzeLogContent, buildRuntimeInspection, } from './index.js';
+import { analyzeLogContent, buildRuntimeInspection } from './index.js';
 const printUsage = () => {
     console.error('Usage: mla-log-tools <path> [--pretty] [--no-events] [--preflight|--runtime-inspection]');
     console.error('  <path>: log file path, zip path, or log directory path');
@@ -44,9 +44,7 @@ const parseArgs = (argv) => {
     return { targetPath, pretty, noEvents, preflight, runtimeInspection };
 };
 const renderOutput = (output, pretty, noEvents) => {
-    const payload = noEvents
-        ? { ...output, events: [] }
-        : output;
+    const payload = noEvents ? { ...output, events: [] } : output;
     return JSON.stringify(payload, null, pretty ? 2 : 0);
 };
 export const MLA_PREFLIGHT_SCHEMA_VERSION = 'mla-preflight/v1';
@@ -97,7 +95,7 @@ export const buildPreflightOutput = (output, framework = EMPTY_FRAMEWORK_EXTRACT
     };
 };
 export const main = async () => {
-    const { targetPath, pretty, noEvents, preflight, runtimeInspection, } = parseArgs(process.argv.slice(2));
+    const { targetPath, pretty, noEvents, preflight, runtimeInspection } = parseArgs(process.argv.slice(2));
     if (preflight && runtimeInspection) {
         console.error('--preflight and --runtime-inspection are mutually exclusive.');
         process.exit(1);
@@ -140,12 +138,14 @@ export const main = async () => {
     else {
         const content = await readNodeTextFileContent(resolvedPath);
         const lineCount = (content.match(/\n/g) ?? []).length + 1;
-        sourceSegments = [{
+        sourceSegments = [
+            {
                 source: `file:${resolvedPath.replace(/\\/g, '/')}`,
                 path: path.basename(resolvedPath),
                 startLine: 1,
                 lineCount,
-            }];
+            },
+        ];
         result = await analyzeLogContent({ content });
     }
     if (!result) {

package/dist/frameworkInput.js

@@ -18,7 +18,7 @@ const decodeBytes = (bytes) => {
 };
 const findEntryPath = (paths, target) => {
     const normalizedTarget = toPosixPath(target).toLowerCase();
-    return paths.find((candidate) => toPosixPath(candidate).toLowerCase() === normalizedTarget) ?? null;
+    return (paths.find((candidate) => toPosixPath(candidate).toLowerCase() === normalizedTarget) ?? null);
 };
 const findZipBasePath = (paths) => {
     for (const candidate of paths) {
@@ -53,12 +53,14 @@ const loadZipSources = async (zipPath, limits) => {
         if (!bytes)
             return [];
         const normalized = toPosixPath(entryPath);
-        return [{
+        return [
+            {
                 path: normalized,
                 name: path.posix.basename(normalized),
                 content: decodeBytes(bytes),
                 reference: `zip:${toPosixPath(zipPath)}#${normalized}`,
-            }];
+            },
+        ];
     });
 };
 const loadDirectorySources = async (directoryPath, limits) => {
@@ -94,10 +96,12 @@ export const loadFrameworkLogSources = async (targetPath, options = {}) => {
     }
     if (targetPath.toLowerCase().endsWith('.zip'))
         return loadZipSources(targetPath, limits);
-    return [{
+    return [
+        {
             path: toPosixPath(targetPath),
             name: path.basename(targetPath),
             content: await readNodeTextFileContent(targetPath, { archiveLimits: limits }),
             reference: `file:${toPosixPath(targetPath)}`,
-        }];
+        },
+    ];
 };

package/dist/frameworkVersion.js

@@ -39,11 +39,7 @@ const buildSession = (source, lines, startIndex, endIndex, startKind, sessionInd
         });
     }
     const versions = [...new Set(versionEvidence.map((item) => item.version))];
-    const status = versions.length === 0
-        ? 'missing_version'
-        : versions.length === 1
-            ? 'resolved'
-            : 'conflict';
+    const status = versions.length === 0 ? 'missing_version' : versions.length === 1 ? 'resolved' : 'conflict';
     const start = position(source, lines, startIndex);
     start.timestamp = findTimestamp(lines, startIndex, endIndex, 1);
     const end = position(source, lines, endIndex);
@@ -71,12 +67,12 @@ export const extractFrameworkSessions = (sources) => {
                 processStarts.push(index);
         }
         const firstProcessStart = processStarts[0];
-        const hasPartialPrefix = firstProcessStart != null
-            && firstProcessStart > 0
-            && lines.slice(0, firstProcessStart).some((line) => (VERSION_PATTERN.test(line) || line.includes('!!!OnEventNotify!!!')));
-        const boundaries = processStarts.length === 0 || hasPartialPrefix
-            ? [0, ...processStarts]
-            : processStarts;
+        const hasPartialPrefix = firstProcessStart != null &&
+            firstProcessStart > 0 &&
+            lines
+                .slice(0, firstProcessStart)
+                .some((line) => VERSION_PATTERN.test(line) || line.includes('!!!OnEventNotify!!!'));
+        const boundaries = processStarts.length === 0 || hasPartialPrefix ? [0, ...processStarts] : processStarts;
         for (let index = 0; index < boundaries.length; index += 1) {
             const startIndex = boundaries[index];
             if (startIndex == null)

package/dist/index.d.ts

@@ -28,7 +28,7 @@ export declare const analyzeLogContent: (input: AnalyzeLogContentInput) => Promi
 export declare const analyzeZipBuffer: (input: AnalyzeZipBufferInput) => Promise<KernelOutput | null>;
 export declare const analyzeZipFile: (input: AnalyzeZipFileInput) => Promise<KernelOutput | null>;
 export declare const analyzeDirectory: (input: AnalyzeDirectoryInput) => Promise<KernelOutput | null>;
-export { DEFAULT_CORE_PARSE_OPTIONS, } from '@windsland52/maa-log-runtime';
+export { DEFAULT_CORE_PARSE_OPTIONS } from '@windsland52/maa-log-runtime';
 export type { AnalyzeLogContentInput, ParseFileOptions } from '@windsland52/maa-log-runtime';
 export * from './nodeInput.js';
 export * from './frameworkInput.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-import { analyzeLogContentWith, DEFAULT_CORE_PARSE_OPTIONS, } from '@windsland52/maa-log-runtime';
+import { analyzeLogContentWith, DEFAULT_CORE_PARSE_OPTIONS } from '@windsland52/maa-log-runtime';
 import { mlaRuntimeAdapter } from '@windsland52/maa-log-adapter';
 import { extractZipContentFromNodeBuffer, extractZipContentFromNodeFile, loadNodeLogDirectory, } from './nodeInput.js';
 export const analyzeLogContent = async (input) => {
@@ -55,7 +55,7 @@ export const analyzeDirectory = async (input) => {
         parserVersion: input.parserVersion,
     });
 };
-export { DEFAULT_CORE_PARSE_OPTIONS, } from '@windsland52/maa-log-runtime';
+export { DEFAULT_CORE_PARSE_OPTIONS } from '@windsland52/maa-log-runtime';
 export * from './nodeInput.js';
 export * from './frameworkInput.js';
 export * from './frameworkVersion.js';

package/dist/nextListPresentation.js

@@ -12,7 +12,7 @@ export const resolveRecognitionNextListName = (attempt, nextListNames) => {
     return attempt.name || '';
 };
 export const buildRecognitionTargetByNextName = (attempts, nextList) => {
-    const nextListNames = new Set(nextList.map(item => item.name));
+    const nextListNames = new Set(nextList.map((item) => item.name));
     const result = new Map();
     attempts.forEach((attempt) => {
         const matchName = resolveRecognitionNextListName(attempt, nextListNames);

package/dist/nodeExecutionName.js

@@ -55,7 +55,7 @@ export const resolveNodeMatchedNextListItem = (node) => {
     if (nextNames.size === 0)
         return undefined;
     const nextItemByName = new Map();
-    for (const nextItem of (node.next_list || [])) {
+    for (const nextItem of node.next_list || []) {
         if (!nextItem?.name || nextItemByName.has(nextItem.name))
             continue;
         nextItemByName.set(nextItem.name, nextItem);

package/dist/nodeExecutionTimeline.js

@@ -1,4 +1,4 @@
-import { resolveNodeExecutionName, resolveNodeMatchedRecognitionName, } from './nodeExecutionName.js';
+import { resolveNodeExecutionName, resolveNodeMatchedRecognitionName } from './nodeExecutionName.js';
 import { sortNodesByGlobalExecutionOrder } from './taskExecutionOrder.js';
 const isNodeActionFailed = (node) => {
     if (node.action_details && node.action_details.success === false)

package/dist/nodeInput.js

@@ -8,10 +8,7 @@ const MAIN_LOG_NAMES = ['maa.log', 'maafw.log'];
 const BAK_LOG_NAMES = ['maa.bak.log', 'maafw.bak.log'];
 const SEARCH_TEXT_EXTENSIONS = ['.log', '.txt', '.jsonl'];
 const MAIN_LOG_NAME_SET = new Set(MAIN_LOG_NAMES.map((name) => name.toLowerCase()));
-const HISTORY_LOG_NAME_PATTERNS = [
-    /^maa\.bak(?:\..+)?\.log$/i,
-    /^maafw\.bak(?:\..+)?\.log$/i,
-];
+const HISTORY_LOG_NAME_PATTERNS = [/^maa\.bak(?:\..+)?\.log$/i, /^maafw\.bak(?:\..+)?\.log$/i];
 const toPosixPath = (value) => value.replace(/\\/g, '/');
 const normalizeLowerPath = (value) => toPosixPath(value).toLowerCase();
 const isSearchTextFile = (normalizedPath) => {
@@ -111,9 +108,9 @@ const toFileReference = (absolutePath) => {
 };
 const isRelativeImagePath = (relativePath, directory, extension) => {
     const normalized = relativePath.toLowerCase();
-    return normalized === `${directory}${extension}`
-        || normalized.startsWith(`${directory}/`)
-        || normalized.includes(`/${directory}/`);
+    return (normalized === `${directory}${extension}` ||
+        normalized.startsWith(`${directory}/`) ||
+        normalized.includes(`/${directory}/`));
 };
 const normalizeTimestampBoundary = (value) => {
     if (!value)
@@ -159,7 +156,7 @@ const countNewlines = (content) => {
     return count;
 };
 const joinMergedWithSources = (chunks) => {
-    let content = "";
+    let content = '';
     let runningNewlines = 0;
     const chunkStarts = [];
     for (const chunk of chunks) {
@@ -180,7 +177,7 @@ const joinMergedWithSources = (chunks) => {
         runningNewlines += countNewlines(chunk.content);
     }
     if (chunkStarts.length === 0) {
-        return { content: "", segments: [] };
+        return { content: '', segments: [] };
     }
     const totalLines = runningNewlines + 1;
     const segments = chunkStarts.map((info, i) => ({
@@ -295,7 +292,9 @@ const readNodeTextFileWithinBudget = async (filePath, context) => {
     const limitCode = context.limits.maxFileBytes <= remainingBytes ? 'file-size' : 'extracted-size';
     const bytes = await readBoundedRegularFile(filePath, maxBytes, (actualBytes) => new ArchiveLimitError(limitCode, limitCode === 'extracted-size'
         ? context.extraction.extractedBytes + actualBytes
-        : actualBytes, limitCode === 'extracted-size' ? context.limits.maxExtractedBytes : context.limits.maxFileBytes), { expectedIdentity: context.discoveredIdentities.get(pathKey(filePath)) });
+        : actualBytes, limitCode === 'extracted-size'
+        ? context.limits.maxExtractedBytes
+        : context.limits.maxFileBytes), { expectedIdentity: context.discoveredIdentities.get(pathKey(filePath)) });
     context.extraction = addSelectedEntry(context.extraction, createStoredFileMetadata(toPosixPath(filePath), bytes.byteLength), context.limits, false);
     return decodeNodeBytes(bytes);
 };
@@ -369,15 +368,14 @@ const buildDefaultZipContent = (entries, paths, basePath, sourceRef) => {
 };
 export const readNodeTextFileContent = async (filePath, options = {}) => {
     const limits = resolveArchiveLimits(options.archiveLimits);
-    const context = options.budgetContext ?? await createNodeInputBudgetContext(path.dirname(path.resolve(filePath)), limits);
+    const context = options.budgetContext ??
+        (await createNodeInputBudgetContext(path.dirname(path.resolve(filePath)), limits));
     return readNodeTextFileWithinBudget(filePath, context);
 };
 export const readNodeTextFilesContent = async (filePaths, options = {}) => {
     const limits = resolveArchiveLimits(options.archiveLimits);
-    const commonRoot = filePaths.length > 0
-        ? path.dirname(path.resolve(filePaths[0]))
-        : process.cwd();
-    const context = options.budgetContext ?? await createNodeInputBudgetContext(commonRoot, limits);
+    const commonRoot = filePaths.length > 0 ? path.dirname(path.resolve(filePaths[0])) : process.cwd();
+    const context = options.budgetContext ?? (await createNodeInputBudgetContext(commonRoot, limits));
     const contents = [];
     for (const filePath of filePaths) {
         contents.push(await readNodeTextFileWithinBudget(filePath, context));
@@ -437,7 +435,14 @@ export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip
         });
     }
     textFiles.sort((a, b) => a.path.localeCompare(b.path));
-    return { content: merged.content, sourceSegments: merged.segments, errorImages, visionImages, waitFreezesImages, textFiles };
+    return {
+        content: merged.content,
+        sourceSegments: merged.segments,
+        errorImages,
+        visionImages,
+        waitFreezesImages,
+        textFiles,
+    };
 };
 export const extractZipContentFromNodeFile = async (zipFilePath, options = {}) => {
     const limits = resolveArchiveLimits(options.archiveLimits);
@@ -505,7 +510,7 @@ const tryInspectDirectory = async (context, directoryPath) => {
     }
 };
 export const hasNodeMainLogInDirectory = async (context, directoryPath) => {
-    if (!await tryInspectDirectory(context, directoryPath))
+    if (!(await tryInspectDirectory(context, directoryPath)))
         return false;
     for (const name of MAIN_LOG_NAMES) {
         const candidatePath = path.join(directoryPath, name);

package/dist/runtimeInspection.js

@@ -49,21 +49,55 @@ const evidence = (index, timestamp) => {
     const after = index.ordered[low];
     const nearest = before == null
         ? after
-        : after == null || target - before.timestamp <= after.timestamp - target ? before : after;
+        : after == null || target - before.timestamp <= after.timestamp - target
+            ? before
+            : after;
     return { timestamp: timestamp ?? null, mergedLine: nearest?.line ?? null };
 };
-const recognitionItems = (items) => ((items ?? []).flatMap(item => [
+const recognitionItems = (items) => (items ?? []).flatMap((item) => [
     ...(item.type === 'recognition' || item.type === 'recognition_node' ? [item] : []),
     ...recognitionItems(item.children),
-]));
+]);
 const imagesFor = (node) => {
     const attempts = recognitionItems(node.node_flow);
     return {
-        error: [node.error_image, ...attempts.map(item => item.error_image)]
+        error: [node.error_image, ...attempts.map((item) => item.error_image)].filter((item) => Boolean(item)),
+        vision: attempts
+            .map((item) => item.vision_image)
             .filter((item) => Boolean(item)),
-        vision: attempts.map(item => item.vision_image).filter((item) => Boolean(item)),
     };
 };
+const ownedRecognitionItems = (items) => (items ?? []).flatMap((item) => {
+    if (item.type === 'task' || item.type === 'pipeline_node')
+        return [];
+    return [
+        ...(item.type === 'recognition' || item.type === 'recognition_node' ? [item] : []),
+        ...ownedRecognitionItems(item.children),
+    ];
+});
+const imagesForFlowItem = (item) => {
+    const attempts = ownedRecognitionItems(item.children);
+    return {
+        error: [item.error_image, ...attempts.map((attempt) => attempt.error_image)].filter((image) => Boolean(image)),
+        vision: [item.vision_image, ...attempts.map((attempt) => attempt.vision_image)].filter((image) => Boolean(image)),
+    };
+};
+const hasFailedOwnedAction = (items) => (items ?? []).some((item) => {
+    if (item.type === 'task' || item.type === 'pipeline_node')
+        return false;
+    if ((item.type === 'action' || item.type === 'action_node') &&
+        (item.status === 'failed' || item.action_details?.success === false))
+        return true;
+    return hasFailedOwnedAction(item.children);
+});
+const hasFailedNestedTask = (items) => (items ?? []).some((item) => item.type === 'task' ? item.status === 'failed' : hasFailedNestedTask(item.children));
+const nestedPipelineFailureKind = (item) => {
+    if (item.status !== 'failed')
+        return null;
+    if (item.action_details?.success === false || hasFailedOwnedAction(item.children))
+        return 'action_failed';
+    return hasFailedNestedTask(item.children) ? null : 'next_list_timeout';
+};
 const scopeFor = (task, sessionId, executionId) => ({
     sessionId,
     executionId,
@@ -71,14 +105,14 @@ const scopeFor = (task, sessionId, executionId) => ({
     taskName: task.entry,
 });
 const sessionFor = (task, sessions) => {
-    const candidates = sessions.filter(session => session.start.timestamp != null
-        && session.end.timestamp != null
-        && task.start_time >= session.start.timestamp
-        && task.start_time <= session.end.timestamp);
-    const complete = candidates.filter(session => session.startKind === 'process_start');
+    const candidates = sessions.filter((session) => session.start.timestamp != null &&
+        session.end.timestamp != null &&
+        task.start_time >= session.start.timestamp &&
+        task.start_time <= session.end.timestamp);
+    const complete = candidates.filter((session) => session.startKind === 'process_start');
     if (complete.length === 1)
         return complete[0] ?? null;
-    const partial = candidates.filter(session => session.startKind === 'partial_file');
+    const partial = candidates.filter((session) => session.startKind === 'partial_file');
     return complete.length === 0 && partial.length === 1 ? (partial[0] ?? null) : null;
 };
 const metricDistribution = (values) => {
@@ -86,7 +120,7 @@ const metricDistribution = (values) => {
         return { count: 0, minimum: 0, p50: 0, p95: 0, maximum: 0, average: 0 };
     }
     const sorted = [...values].sort((left, right) => left - right);
-    const percentile = (ratio) => (sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * ratio) - 1)] ?? 0);
+    const percentile = (ratio) => sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * ratio) - 1)] ?? 0;
     const total = sorted.reduce((sum, value) => sum + value, 0);
     return {
         count: sorted.length,
@@ -111,18 +145,18 @@ const increment = (map, key) => {
 const prioritize = (reasons) => {
     if (reasons.length === 0)
         return { priority: 'low', priorityReasons: [] };
-    if (reasons.includes('timeout')
-        || reasons.includes('unmatched_terminal')
-        || reasons.includes('still_repeating_at_log_end')
-        || reasons.includes('related_to_direct_failure')
-        || reasons.includes('incomplete_repetition')) {
+    if (reasons.includes('timeout') ||
+        reasons.includes('unmatched_terminal') ||
+        reasons.includes('still_repeating_at_log_end') ||
+        reasons.includes('related_to_direct_failure') ||
+        reasons.includes('incomplete_repetition')) {
         return { priority: 'high', priorityReasons: reasons };
     }
-    if (reasons.includes('high_mixed_results')
-        || reasons.includes('high_unsuccessful_attempts')
-        || reasons.includes('high_occurrence_count')
-        || reasons.includes('high_repeat_count')
-        || reasons.includes('long_duration')) {
+    if (reasons.includes('high_mixed_results') ||
+        reasons.includes('high_unsuccessful_attempts') ||
+        reasons.includes('high_occurrence_count') ||
+        reasons.includes('high_repeat_count') ||
+        reasons.includes('long_duration')) {
         return { priority: 'normal', priorityReasons: reasons };
     }
     return { priority: 'low', priorityReasons: reasons };
@@ -135,7 +169,9 @@ const repetitions = (nodes) => {
         for (let length = 1; length <= Math.min(8, Math.floor((nodes.length - start) / 2)); length += 1) {
             let count = 1;
             while (start + (count + 1) * length <= nodes.length) {
-                const same = nodes.slice(start, start + length).every((node, offset) => node.name === nodes[start + count * length + offset]?.name);
+                const same = nodes
+                    .slice(start, start + length)
+                    .every((node, offset) => node.name === nodes[start + count * length + offset]?.name);
                 if (!same)
                     break;
                 count += 1;
@@ -215,7 +251,99 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
         const recognitionOccurrences = [];
         const evidenceIndex = buildEvidenceIndex(task);
         const timeline = buildNodeExecutionTimeline(task.nodes, { rootTaskId: task.task_id });
+        const seenNestedTasks = new Set();
+        const seenNestedPipelines = new Set();
+        const inspectNestedTask = (taskItem) => {
+            if (seenNestedTasks.has(taskItem.id))
+                return;
+            seenNestedTasks.add(taskItem.id);
+            const taskId = taskItem.task_details?.task_id ?? taskItem.task_id;
+            if (taskId == null) {
+                inspectNestedTasks(taskItem.children);
+                return;
+            }
+            const nestedScope = {
+                sessionId,
+                executionId,
+                taskId,
+                taskName: taskItem.task_details?.entry ?? taskItem.name,
+            };
+            const nestedDirectFailureIds = [];
+            const inspectOwnedItems = (items) => {
+                for (const child of items ?? []) {
+                    if (child.type === 'task') {
+                        inspectNestedTask(child);
+                        continue;
+                    }
+                    if (child.type !== 'pipeline_node') {
+                        inspectOwnedItems(child.children);
+                        continue;
+                    }
+                    if (seenNestedPipelines.has(child.id))
+                        continue;
+                    seenNestedPipelines.add(child.id);
+                    inspectOwnedItems(child.children);
+                    const failureKind = nestedPipelineFailureKind(child);
+                    let nodeFailureId = null;
+                    if (failureKind && child.node_id != null) {
+                        nodeFailureId = `failure-${failures.length + 1}`;
+                        const images = imagesForFlowItem(child);
+                        failures.push({
+                            ...nestedScope,
+                            failureId: nodeFailureId,
+                            kind: failureKind,
+                            nodeId: child.node_id,
+                            nodeName: child.name,
+                            startedAt: child.ts,
+                            endedAt: child.end_ts ?? null,
+                            errorImages: [...new Set(images.error)],
+                            visionImages: [...new Set(images.vision)],
+                            evidence: evidenceAt(evidenceIndex, child.end_ts ?? child.ts),
+                        });
+                        nestedDirectFailureIds.push(nodeFailureId);
+                    }
+                    if (child.status !== 'success') {
+                        const outcomeId = `outcome-${outcomes.length + 1}`;
+                        outcomes.push({
+                            ...nestedScope,
+                            outcomeId,
+                            kind: 'pipeline_node',
+                            status: child.status,
+                            nodeId: child.node_id ?? null,
+                            nodeName: child.name,
+                            directFailureIds: nodeFailureId ? [nodeFailureId] : [],
+                            evidence: evidenceAt(evidenceIndex, child.end_ts ?? child.ts),
+                        });
+                        outcomeIds.push(outcomeId);
+                    }
+                }
+            };
+            inspectOwnedItems(taskItem.children);
+            if (taskItem.status !== 'success') {
+                const outcomeId = `outcome-${outcomes.length + 1}`;
+                outcomes.push({
+                    ...nestedScope,
+                    outcomeId,
+                    kind: 'task',
+                    status: taskItem.status,
+                    nodeId: null,
+                    nodeName: null,
+                    directFailureIds: nestedDirectFailureIds,
+                    evidence: evidenceAt(evidenceIndex, taskItem.end_ts ?? taskItem.ts),
+                });
+                outcomeIds.push(outcomeId);
+            }
+        };
+        const inspectNestedTasks = (items) => {
+            for (const item of items ?? []) {
+                if (item.type === 'task')
+                    inspectNestedTask(item);
+                else
+                    inspectNestedTasks(item.children);
+            }
+        };
         for (const item of timeline) {
+            inspectNestedTasks(item.nodeInfo.node_flow);
             const failureKind = item.navStatus === 'action-failed'
                 ? 'action_failed'
                 : item.navStatus === 'timeout' && item.nodeInfo.next_list.length > 0
@@ -254,17 +382,19 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                 outcomeIds.push(outcomeId);
             }
             const attempts = recognitionItems(item.nodeInfo.node_flow);
-            const missed = attempts.filter(attempt => attempt.status === 'failed');
+            const missed = attempts.filter((attempt) => attempt.status === 'failed');
             if (item.nodeInfo.next_list.length > 0) {
                 const terminalOutcome = item.navStatus === 'timeout'
                     ? 'timeout'
                     : item.nodeInfo.status === 'running'
                         ? 'running'
-                        : item.matchedRecognitionName ? 'matched' : 'unmatched';
+                        : item.matchedRecognitionName
+                            ? 'matched'
+                            : 'unmatched';
                 recognitionOccurrences.push({
                     nodeId: item.nodeInfo.node_id,
                     pipelineNodeName: item.nodeInfo.name,
-                    nextList: item.nodeInfo.next_list.map(next => ({
+                    nextList: item.nodeInfo.next_list.map((next) => ({
                         name: next.name,
                         anchor: next.anchor,
                         jumpBack: next.jump_back,
@@ -303,14 +433,17 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             const signalId = `signal-${signals.length + 1}`;
             const terminalMatches = new Map();
             const terminalOutcomes = { matched: 0, timeout: 0, running: 0, unmatched: 0 };
-            const candidates = new Map(firstOccurrence.nextList.map(next => [next.name, {
+            const candidates = new Map(firstOccurrence.nextList.map((next) => [
+                next.name,
+                {
                     name: next.name,
                     evaluationCount: 0,
                     matchedAttemptCount: 0,
                     unsuccessfulAttemptCount: 0,
                     runningAttemptCount: 0,
                     terminalMatchCount: 0,
-                }]));
+                },
+            ]));
             let unmappedAttemptCount = 0;
             let occurrencesWithMixedResults = 0;
             for (const occurrence of group) {
@@ -321,7 +454,7 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                     if (candidate)
                         candidate.terminalMatchCount += 1;
                 }
-                const statuses = new Set(occurrence.attempts.map(attempt => attempt.status));
+                const statuses = new Set(occurrence.attempts.map((attempt) => attempt.status));
                 if (statuses.has('failed') && statuses.has('success'))
                     occurrencesWithMixedResults += 1;
                 const nextNames = new Set(candidates.keys());
@@ -341,11 +474,11 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                         candidate.runningAttemptCount += 1;
                 }
             }
-            const worstOccurrence = [...group].sort((left, right) => (right.sample.unsuccessfulAttempts - left.sample.unsuccessfulAttempts
-                || right.sample.attemptCount - left.sample.attemptCount))[0] ?? firstOccurrence;
-            const attemptsDist = metricDistribution(group.map(item => item.sample.attemptCount));
-            const unsuccessfulDist = metricDistribution(group.map(item => item.sample.unsuccessfulAttempts));
-            const durationDist = metricDistribution(group.flatMap(item => item.durationMs == null ? [] : [item.durationMs]));
+            const worstOccurrence = [...group].sort((left, right) => right.sample.unsuccessfulAttempts - left.sample.unsuccessfulAttempts ||
+                right.sample.attemptCount - left.sample.attemptCount)[0] ?? firstOccurrence;
+            const attemptsDist = metricDistribution(group.map((item) => item.sample.attemptCount));
+            const unsuccessfulDist = metricDistribution(group.map((item) => item.sample.unsuccessfulAttempts));
+            const durationDist = metricDistribution(group.flatMap((item) => (item.durationMs == null ? [] : [item.durationMs])));
             const reasons = [];
             if (terminalOutcomes.timeout > 0)
                 reasons.push('timeout');
@@ -357,7 +490,8 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                 reasons.push('high_unsuccessful_attempts');
             if (group.length >= 20)
                 reasons.push('high_occurrence_count');
-            if (group.some(item => item.sample.nodeId && failures.some(failure => failure.nodeId === item.sample.nodeId && failure.executionId === scope.executionId))) {
+            if (group.some((item) => item.sample.nodeId &&
+                failures.some((failure) => failure.nodeId === item.sample.nodeId && failure.executionId === scope.executionId))) {
                 reasons.push('related_to_direct_failure');
             }
             const ranking = prioritize(reasons);
@@ -370,7 +504,8 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                 occurrenceCount: group.length,
                 occurrencesWithMixedResults,
                 terminalOutcomes,
-                terminalMatches: [...terminalMatches].map(([name, count]) => ({ name, count }))
+                terminalMatches: [...terminalMatches]
+                    .map(([name, count]) => ({ name, count }))
                     .sort((left, right) => right.count - left.count),
                 candidateStatistics: [...candidates.values()],
                 unmappedAttemptCount,
@@ -387,7 +522,9 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             });
             signalIds.push(signalId);
         }
-        const completed = timeline.map(item => item.nodeInfo).filter(node => node.status !== 'running');
+        const completed = timeline
+            .map((item) => item.nodeInfo)
+            .filter((node) => node.status !== 'running');
         const repetitionGroups = new Map();
         for (const repeated of repetitions(completed)) {
             const first = completed[repeated.start];
@@ -395,21 +532,23 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             const last = completed[lastIndex];
             if (!first || !last)
                 continue;
-            const rawPattern = completed.slice(repeated.start, repeated.start + repeated.length).map(node => node.name);
+            const rawPattern = completed
+                .slice(repeated.start, repeated.start + repeated.length)
+                .map((node) => node.name);
             const pattern = repeated.length === 1 ? rawPattern : canonicalCycle(rawPattern);
             const kind = repeated.length === 1 ? 'repeated_node' : 'repeated_node_cycle';
             const key = JSON.stringify([kind, pattern]);
             const group = repetitionGroups.get(key) ?? [];
-            const timelineLastIndex = timeline.findIndex(item => item.nodeInfo === last);
+            const timelineLastIndex = timeline.findIndex((item) => item.nodeInfo === last);
             const trailing = timelineLastIndex < 0 ? [] : timeline.slice(timelineLastIndex + 1);
             const reachesCompletedEnd = lastIndex === completed.length - 1;
-            const continuesAtLogEnd = reachesCompletedEnd
-                && task.status === 'running'
-                && trailing.every((item, offset) => (item.nodeInfo.status === 'running'
-                    && item.nodeInfo.name === rawPattern[offset % rawPattern.length]));
-            const taskEndedAtPattern = reachesCompletedEnd
-                && timelineLastIndex === timeline.length - 1
-                && task.status !== 'running';
+            const continuesAtLogEnd = reachesCompletedEnd &&
+                task.status === 'running' &&
+                trailing.every((item, offset) => item.nodeInfo.status === 'running' &&
+                    item.nodeInfo.name === rawPattern[offset % rawPattern.length]);
+            const taskEndedAtPattern = reachesCompletedEnd &&
+                timelineLastIndex === timeline.length - 1 &&
+                task.status !== 'running';
             group.push({
                 pattern,
                 repeatCount: repeated.count,
@@ -418,7 +557,9 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                 lastSeenAt: last.end_ts ?? last.ts,
                 termination: continuesAtLogEnd
                     ? 'still_repeating_at_log_end'
-                    : taskEndedAtPattern ? 'task_ended' : 'left_pattern',
+                    : taskEndedAtPattern
+                        ? 'task_ended'
+                        : 'left_pattern',
                 evidence: evidenceAt(evidenceIndex, first.ts),
             });
             repetitionGroups.set(key, group);
@@ -431,12 +572,12 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             const longest = [...group].sort((left, right) => right.durationMs - left.durationMs)[0] ?? first;
             const signalId = `signal-${signals.length + 1}`;
             const terminations = {
-                leftPattern: group.filter(item => item.termination === 'left_pattern').length,
-                taskEnded: group.filter(item => item.termination === 'task_ended').length,
-                stillRepeatingAtLogEnd: group.filter(item => item.termination === 'still_repeating_at_log_end').length,
+                leftPattern: group.filter((item) => item.termination === 'left_pattern').length,
+                taskEnded: group.filter((item) => item.termination === 'task_ended').length,
+                stillRepeatingAtLogEnd: group.filter((item) => item.termination === 'still_repeating_at_log_end').length,
             };
             const totalRepeatCount = group.reduce((sum, item) => sum + item.repeatCount, 0);
-            const maximumRepeatCount = Math.max(...group.map(item => item.repeatCount));
+            const maximumRepeatCount = Math.max(...group.map((item) => item.repeatCount));
             const repetitionReasons = [];
             if (terminations.stillRepeatingAtLogEnd > 0)
                 repetitionReasons.push('still_repeating_at_log_end');
@@ -451,7 +592,7 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
                 segmentCount: group.length,
                 totalRepeatCount,
                 maximumRepeatCount,
-                durationMs: metricDistribution(group.map(item => item.durationMs)),
+                durationMs: metricDistribution(group.map((item) => item.durationMs)),
                 terminations,
                 representatives: {
                     first: first,
@@ -483,25 +624,25 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             });
             outcomeIds.push(outcomeId);
         }
-        const attemptsByNode = timeline.map(item => recognitionItems(item.nodeInfo.node_flow));
+        const attemptsByNode = timeline.map((item) => recognitionItems(item.nodeInfo.node_flow));
         const allAttempts = attemptsByNode.flat();
-        const imageSets = timeline.map(item => imagesFor(item.nodeInfo));
-        const errorImages = imageSets.flatMap(set => set.error);
-        const visionImages = imageSets.flatMap(set => set.vision);
-        const ownFailures = failures.filter(failure => directFailureIds.includes(failure.failureId));
-        const ownSignals = signals.filter(signal => signalIds.includes(signal.signalId));
-        const recognitionSignals = ownSignals
-            .filter((signal) => (signal.kind === 'recognition_activity'));
+        const imageSets = timeline.map((item) => imagesFor(item.nodeInfo));
+        const errorImages = imageSets.flatMap((set) => set.error);
+        const visionImages = imageSets.flatMap((set) => set.vision);
+        const ownFailures = failures.filter((failure) => directFailureIds.includes(failure.failureId));
+        const ownSignals = signals.filter((signal) => signalIds.includes(signal.signalId));
+        const recognitionSignals = ownSignals.filter((signal) => signal.kind === 'recognition_activity');
         const recognitionActivity = [...recognitionSignals]
-            .sort((left, right) => (right.unsuccessfulAttempts.maximum - left.unsuccessfulAttempts.maximum
-            || right.occurrenceCount - left.occurrenceCount))
+            .sort((left, right) => right.unsuccessfulAttempts.maximum - left.unsuccessfulAttempts.maximum ||
+            right.occurrenceCount - left.occurrenceCount)
             .slice(0, 5)
-            .map(signal => signal.signalId);
+            .map((signal) => signal.signalId);
         const repetitionSignals = ownSignals
             .filter((signal) => signal.kind !== 'recognition_activity')
-            .sort((left, right) => (right.totalRepeatCount * right.pattern.length - left.totalRepeatCount * left.pattern.length))
+            .sort((left, right) => right.totalRepeatCount * right.pattern.length -
+            left.totalRepeatCount * left.pattern.length)
             .slice(0, 5)
-            .map(signal => signal.signalId);
+            .map((signal) => signal.signalId);
         return {
             executionId: scope.executionId,
             taskId: task.task_id,
@@ -517,22 +658,24 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             lastNode: timeline[timeline.length - 1]?.executionName ?? null,
             statistics: {
                 nodeExecutions: timeline.length,
-                succeededNodes: timeline.filter(item => item.nodeInfo.status === 'success').length,
-                failedNodes: timeline.filter(item => item.nodeInfo.status === 'failed').length,
-                runningNodes: timeline.filter(item => item.nodeInfo.status === 'running').length,
+                succeededNodes: timeline.filter((item) => item.nodeInfo.status === 'success').length,
+                failedNodes: timeline.filter((item) => item.nodeInfo.status === 'failed').length,
+                runningNodes: timeline.filter((item) => item.nodeInfo.status === 'running').length,
                 recognitionAttempts: allAttempts.length,
-                unsuccessfulRecognitionAttempts: allAttempts.filter(attempt => attempt.status === 'failed').length,
-                nodeExecutionsWithRecognition: attemptsByNode.filter(attempts => attempts.length > 0).length,
-                nodeExecutionsWithMixedRecognitionResults: attemptsByNode.filter(attempts => {
-                    const statuses = new Set(attempts.map(attempt => attempt.status));
+                unsuccessfulRecognitionAttempts: allAttempts.filter((attempt) => attempt.status === 'failed').length,
+                nodeExecutionsWithRecognition: attemptsByNode.filter((attempts) => attempts.length > 0)
+                    .length,
+                nodeExecutionsWithMixedRecognitionResults: attemptsByNode.filter((attempts) => {
+                    const statuses = new Set(attempts.map((attempt) => attempt.status));
                     return statuses.has('failed') && statuses.has('success');
                 }).length,
                 recognitionActivityGroups: recognitionSignals.length,
-                maximumRecognitionAttemptsPerNode: Math.max(0, ...attemptsByNode.map(attempts => attempts.length)),
-                maximumUnsuccessfulRecognitionAttemptsPerNode: Math.max(0, ...attemptsByNode.map(attempts => attempts.filter(attempt => attempt.status === 'failed').length)),
-                actionAttempts: timeline.filter(item => item.nodeInfo.action_details != null).length,
-                actionFailures: ownFailures.filter(failure => failure.kind === 'action_failed').length,
-                nextListTimeouts: ownFailures.filter(failure => failure.kind === 'next_list_timeout').length,
+                maximumRecognitionAttemptsPerNode: Math.max(0, ...attemptsByNode.map((attempts) => attempts.length)),
+                maximumUnsuccessfulRecognitionAttemptsPerNode: Math.max(0, ...attemptsByNode.map((attempts) => attempts.filter((attempt) => attempt.status === 'failed').length)),
+                actionAttempts: timeline.filter((item) => item.nodeInfo.action_details != null).length,
+                actionFailures: ownFailures.filter((failure) => failure.kind === 'action_failed').length,
+                nextListTimeouts: ownFailures.filter((failure) => failure.kind === 'next_list_timeout')
+                    .length,
                 errorImageReferences: errorImages.length,
                 uniqueErrorImages: new Set(errorImages).size,
                 visionImageReferences: visionImages.length,
@@ -550,9 +693,9 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
     };
     const tasks = output.tasks.map(buildTask);
     const sessions = framework.sessions.map((session) => {
-        const scoped = tasks.filter(task => executionSessionIds.get(task.executionId) === session.sessionId);
-        const ids = new Set(scoped.flatMap(task => task.directFailureIds));
-        const scopedFailures = failures.filter(failure => ids.has(failure.failureId));
+        const scoped = tasks.filter((task) => executionSessionIds.get(task.executionId) === session.sessionId);
+        const ids = new Set(scoped.flatMap((task) => task.directFailureIds));
+        const scopedFailures = failures.filter((failure) => ids.has(failure.failureId));
         return {
             sessionId: session.sessionId,
             startKind: session.startKind,
@@ -564,17 +707,18 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
             tasks: scoped,
             summary: {
                 taskExecutions: scoped.length,
-                succeededTasks: scoped.filter(task => task.status === 'succeeded').length,
-                failedTasks: scoped.filter(task => task.status === 'failed').length,
-                runningTasks: scoped.filter(task => task.status === 'running').length,
+                succeededTasks: scoped.filter((task) => task.status === 'succeeded').length,
+                failedTasks: scoped.filter((task) => task.status === 'failed').length,
+                runningTasks: scoped.filter((task) => task.status === 'running').length,
                 directFailures: scopedFailures.length,
-                nextListTimeouts: scopedFailures.filter(failure => failure.kind === 'next_list_timeout').length,
-                actionFailures: scopedFailures.filter(failure => failure.kind === 'action_failed').length,
+                nextListTimeouts: scopedFailures.filter((failure) => failure.kind === 'next_list_timeout')
+                    .length,
+                actionFailures: scopedFailures.filter((failure) => failure.kind === 'action_failed').length,
                 signals: scoped.reduce((count, task) => count + task.signalIds.length, 0),
             },
         };
     });
-    const unscopedTasks = tasks.filter(task => executionSessionIds.get(task.executionId) == null);
+    const unscopedTasks = tasks.filter((task) => executionSessionIds.get(task.executionId) == null);
     return {
         schemaVersion: MLA_RUNTIME_INSPECTION_SCHEMA_VERSION,
         sessions,
@@ -585,7 +729,9 @@ export const buildRuntimeInspection = (output, framework, sourceSegments) => {
         warnings: [
             ...framework.warnings,
             ...(unscopedTasks.length
-                ? [`${unscopedTasks.length} task execution(s) could not be assigned to one runtime session.`]
+                ? [
+                    `${unscopedTasks.length} task execution(s) could not be assigned to one runtime session.`,
+                ]
                 : []),
         ],
     };

package/dist/taskExecutionOrder.js

@@ -26,5 +26,5 @@ export const sortNodesByGlobalExecutionOrder = (nodes) => {
         }
         return left.index - right.index;
     })
-        .map(item => item.node);
+        .map((item) => item.node);
 };

package/dist/taskIdentity.js

@@ -19,8 +19,10 @@ export const buildTaskIdentity = (task) => {
 export const isSameTask = (left, right) => {
     if (left === right)
         return true;
-    if (typeof left._startEventIndex === 'number' && left._startEventIndex >= 0
-        && typeof right._startEventIndex === 'number' && right._startEventIndex >= 0) {
+    if (typeof left._startEventIndex === 'number' &&
+        left._startEventIndex >= 0 &&
+        typeof right._startEventIndex === 'number' &&
+        right._startEventIndex >= 0) {
         return left._startEventIndex === right._startEventIndex;
     }
     const leftUuid = normalize(left.uuid);
@@ -32,12 +34,12 @@ export const isSameTask = (left, right) => {
     return buildCompositeIdentity(left) === buildCompositeIdentity(right);
 };
 export const findTaskIndex = (tasks, target) => {
-    const byRef = tasks.findIndex(task => task === target);
+    const byRef = tasks.findIndex((task) => task === target);
     if (byRef >= 0)
         return byRef;
-    const byIdentity = tasks.findIndex(task => isSameTask(task, target));
+    const byIdentity = tasks.findIndex((task) => isSameTask(task, target));
     if (byIdentity >= 0)
         return byIdentity;
     const targetIdentity = buildTaskIdentity(target);
-    return tasks.findIndex(task => buildTaskIdentity(task) === targetIdentity);
+    return tasks.findIndex((task) => buildTaskIdentity(task) === targetIdentity);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windsland52/maa-log-tools",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "type": "module",
   "private": false,
   "bin": {
@@ -43,8 +43,8 @@
   "dependencies": {
     "fflate": "^0.8.2",
     "@windsland52/maa-log-adapter": "1.1.0",
-    "@windsland52/maa-log-parser": "1.1.0",
     "@windsland52/maa-log-kernel": "1.0.2",
+    "@windsland52/maa-log-parser": "1.2.0",
     "@windsland52/maa-log-runtime": "1.1.0"
   },
   "engines": {