@windsland52/maa-log-tools 1.3.0 → 1.3.1

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/runtimeInspection.js

@@ -64,6 +64,39 @@ const imagesFor = (node) => {
         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,
@@ -215,7 +248,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windsland52/maa-log-tools",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "type": "module",
   "private": false,
   "bin": {
@@ -42,9 +42,9 @@
   },
   "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-adapter": "1.1.0",
     "@windsland52/maa-log-runtime": "1.1.0"
   },
   "engines": {