@windsland52/maa-log-tools 1.1.0 → 1.2.0

package/README.md

@@ -25,6 +25,7 @@ The concrete adapter is provided by `@windsland52/maa-log-adapter`.
   - `loadFrameworkLogSources`
   - `extractFrameworkSessions`
   - `resolveFrameworkSessionForTimestamp`
+  - `buildRuntimeInspection`
   - `DEFAULT_CORE_PARSE_OPTIONS`
 - `@windsland52/maa-log-tools/node-input`
   - Node file/zip/folder extraction helpers
@@ -49,7 +50,7 @@ When `focus` is provided, the helpers scan candidate primary and history log fil
 ## CLI
 
 ```bash
-pnpm kernel:cli <path> [--pretty] [--no-events] [--preflight]
+pnpm kernel:cli <path> [--pretty] [--no-events] [--preflight|--runtime-inspection]
 ```
 
 `<path>` can be a log file, a zip file, or a log directory.
@@ -67,3 +68,33 @@ and content before a process-start marker is explicitly marked as a partial file
 Use the session containing the relevant failure timestamp when selecting version-matched source.
 `resolveFrameworkSessionForTimestamp` returns a session only when exactly one resolved,
 process-start-bounded interval contains the timestamp; otherwise it returns `null`.
+
+## Runtime inspection
+
+`buildRuntimeInspection(kernelOutput, frameworkExtraction, sourceSegments?)` emits
+`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.
+- `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
+  repeated completed-node sequences.
+
+An unsuccessful recognition attempt is retry telemetry, not a failure. A next-list failure is
+reported only when the node finishes without matching a candidate. Repeated recognition attempts
+inside one node are not treated as pipeline loops.
+
+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.
+
+Use `--runtime-inspection` to emit this result directly from a file, zip, or directory. It is a
+separate output mode from `--preflight`; the two flags are mutually exclusive.
+
+When `sourceSegments` is provided, each evidence position is enriched with `source`, `path`, and
+`localLine` describing which original log file the evidence came from and its 1-based line within
+that file. Segments are built by the Node extraction helpers (`loadNodeLogDirectory`,
+`extractZipContentFromNodeFile`) when merging multiple log files; `parserInputLine` remains the
+line in the merged parser input, while `localLine` is the offset within the individual source
+file. Callers without segments leave these fields as `null`.

package/dist/cli.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import type { KernelOutput } from '@windsland52/maa-log-kernel/protocol';
-import { type FrameworkSession, type FrameworkSessionExtraction, type FrameworkVersionSummary } from './frameworkVersion';
+import { type FrameworkSession, type FrameworkSessionExtraction, type FrameworkVersionSummary } from './frameworkVersion.js';
 export declare const MLA_PREFLIGHT_SCHEMA_VERSION = "mla-preflight/v1";
 export type PreflightReason = 'notify_events_parsed' | 'empty_log' | 'no_notify_events' | 'no_task_lifecycle' | 'no_analyzable_content';
 export interface PreflightOutput {

package/dist/cli.js

@@ -4,10 +4,10 @@ import path from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { loadFrameworkLogSources } from './frameworkInput.js';
 import { extractFrameworkSessions, } from './frameworkVersion.js';
-import { readNodeTextFileContent } from './nodeInput.js';
-import { analyzeLogContent, analyzeDirectory, analyzeZipFile, } from './index.js';
+import { loadNodeLogDirectory, extractZipContentFromNodeFile, readNodeTextFileContent, } from './nodeInput.js';
+import { analyzeLogContent, buildRuntimeInspection, } from './index.js';
 const printUsage = () => {
-    console.error('Usage: mla-log-tools <path> [--pretty] [--no-events] [--preflight]');
+    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');
 };
 const parseArgs = (argv) => {
@@ -15,6 +15,7 @@ const parseArgs = (argv) => {
     let pretty = false;
     let noEvents = false;
     let preflight = false;
+    let runtimeInspection = false;
     for (const arg of argv) {
         if (arg === '--pretty') {
             pretty = true;
@@ -28,6 +29,10 @@ const parseArgs = (argv) => {
             preflight = true;
             continue;
         }
+        if (arg === '--runtime-inspection') {
+            runtimeInspection = true;
+            continue;
+        }
         if (arg === '--help' || arg === '-h') {
             printUsage();
             process.exit(0);
@@ -36,7 +41,7 @@ const parseArgs = (argv) => {
             targetPath = arg;
         }
     }
-    return { targetPath, pretty, noEvents, preflight };
+    return { targetPath, pretty, noEvents, preflight, runtimeInspection };
 };
 const renderOutput = (output, pretty, noEvents) => {
     const payload = noEvents
@@ -88,25 +93,55 @@ export const buildPreflightOutput = (output, framework = EMPTY_FRAMEWORK_EXTRACT
     };
 };
 export const main = async () => {
-    const { targetPath, pretty, noEvents, preflight, } = 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);
+    }
     if (!targetPath) {
         printUsage();
         process.exit(1);
     }
     const resolvedPath = path.resolve(targetPath);
     const targetStat = await stat(resolvedPath);
-    const framework = preflight
+    const framework = preflight || runtimeInspection
         ? extractFrameworkSessions(await loadFrameworkLogSources(resolvedPath))
         : EMPTY_FRAMEWORK_EXTRACTION;
     let result = null;
+    let sourceSegments;
     if (targetStat.isDirectory()) {
-        result = await analyzeDirectory({ directoryPath: resolvedPath });
+        const extracted = await loadNodeLogDirectory(resolvedPath);
+        if (extracted) {
+            sourceSegments = extracted.sourceSegments;
+            result = await analyzeLogContent({
+                content: extracted.content,
+                errorImages: extracted.errorImages,
+                visionImages: extracted.visionImages,
+                waitFreezesImages: extracted.waitFreezesImages,
+            });
+        }
     }
     else if (resolvedPath.toLowerCase().endsWith('.zip')) {
-        result = await analyzeZipFile({ zipFilePath: resolvedPath });
+        const extracted = await extractZipContentFromNodeFile(resolvedPath);
+        if (extracted) {
+            sourceSegments = extracted.sourceSegments;
+            result = await analyzeLogContent({
+                content: extracted.content,
+                errorImages: extracted.errorImages,
+                visionImages: extracted.visionImages,
+                waitFreezesImages: extracted.waitFreezesImages,
+            });
+        }
     }
     else {
         const content = await readNodeTextFileContent(resolvedPath);
+        const lineCount = (content.match(/\n/g) ?? []).length + 1;
+        sourceSegments = [{
+                source: `file:${resolvedPath.replace(/\\/g, '/')}`,
+                path: path.basename(resolvedPath),
+                startLine: 1,
+                lineCount,
+            }];
         result = await analyzeLogContent({ content });
     }
     if (!result) {
@@ -126,6 +161,11 @@ export const main = async () => {
         }
         return;
     }
+    if (runtimeInspection) {
+        process.stdout.write(JSON.stringify(buildRuntimeInspection(result, framework, sourceSegments), null, pretty ? 2 : 0));
+        process.stdout.write('\n');
+        return;
+    }
     process.stdout.write(renderOutput(result, pretty, noEvents));
     process.stdout.write('\n');
 };

package/dist/frameworkInput.d.ts

@@ -1,2 +1,2 @@
-import type { FrameworkLogSource } from './frameworkVersion';
+import type { FrameworkLogSource } from './frameworkVersion.js';
 export declare const loadFrameworkLogSources: (targetPath: string) => Promise<FrameworkLogSource[]>;

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { KernelOutput } from '@windsland52/maa-log-kernel';
 import type { AnalyzeLogContentInput, ParseFileOptions } from '@windsland52/maa-log-runtime';
-import { type LogBundleFocus } from './nodeInput';
+import { type LogBundleFocus } from './nodeInput.js';
 type ParseOptions = ParseFileOptions;
 export interface AnalyzeZipBufferInput {
     zipData: Uint8Array;
@@ -27,6 +27,7 @@ export declare const analyzeZipFile: (input: AnalyzeZipFileInput) => Promise<Ker
 export declare const analyzeDirectory: (input: AnalyzeDirectoryInput) => Promise<KernelOutput | null>;
 export { DEFAULT_CORE_PARSE_OPTIONS, } from '@windsland52/maa-log-runtime';
 export type { AnalyzeLogContentInput, ParseFileOptions } from '@windsland52/maa-log-runtime';
-export * from './nodeInput';
-export * from './frameworkInput';
-export * from './frameworkVersion';
+export * from './nodeInput.js';
+export * from './frameworkInput.js';
+export * from './frameworkVersion.js';
+export * from './runtimeInspection.js';

package/dist/index.js

@@ -56,3 +56,4 @@ export { DEFAULT_CORE_PARSE_OPTIONS, } from '@windsland52/maa-log-runtime';
 export * from './nodeInput.js';
 export * from './frameworkInput.js';
 export * from './frameworkVersion.js';
+export * from './runtimeInspection.js';

package/dist/nodeInput.d.ts

@@ -1,3 +1,4 @@
+import type { SourceSegment } from './runtimeInspection.js';
 export interface KernelTextFile {
     path: string;
     name: string;
@@ -10,6 +11,7 @@ export interface NodeExtractedLogContent {
     visionImages: Map<string, string>;
     waitFreezesImages: Map<string, string>;
     textFiles: KernelTextFile[];
+    sourceSegments: SourceSegment[];
 }
 export interface LogBundleFocus {
     keywords?: string[];

package/dist/nodeInput.js

@@ -146,14 +146,49 @@ const contentMatchesFocus = (content, focus) => {
         return true;
     });
 };
-const joinMergedContent = (chunks) => {
-    return chunks.reduce((result, chunk) => {
-        if (chunk.length === 0)
-            return result;
-        if (result.length === 0)
-            return chunk;
-        return result.endsWith('\n') ? `${result}${chunk}` : `${result}\n${chunk}`;
-    }, '');
+const countNewlines = (content) => {
+    let count = 0;
+    let pos = 0;
+    while ((pos = content.indexOf(String.fromCharCode(10), pos)) >= 0) {
+        count += 1;
+        pos += 1;
+    }
+    return count;
+};
+const joinMergedWithSources = (chunks) => {
+    let content = "";
+    let runningNewlines = 0;
+    const chunkStarts = [];
+    for (const chunk of chunks) {
+        if (chunk.content.length === 0)
+            continue;
+        if (content.length === 0) {
+            content = chunk.content;
+        }
+        else if (content.endsWith(String.fromCharCode(10))) {
+            content += chunk.content;
+        }
+        else {
+            content += String.fromCharCode(10) + chunk.content;
+            runningNewlines += 1;
+        }
+        const startLine = runningNewlines + 1;
+        chunkStarts.push({ startLine, source: chunk.source, path: chunk.path });
+        runningNewlines += countNewlines(chunk.content);
+    }
+    if (chunkStarts.length === 0) {
+        return { content: "", segments: [] };
+    }
+    const totalLines = runningNewlines + 1;
+    const segments = chunkStarts.map((info, i) => ({
+        source: info.source,
+        path: info.path,
+        startLine: info.startLine,
+        lineCount: i < chunkStarts.length - 1
+            ? chunkStarts[i + 1].startLine - info.startLine
+            : totalLines - info.startLine + 1,
+    }));
+    return { content, segments };
 };
 const rankLogPath = (filePath) => {
     const baseName = path.basename(filePath).toLowerCase();
@@ -185,11 +220,15 @@ const collectFocusedFileContents = async (logPaths, focus) => {
         const content = await readNodeTextFileContent(logPath);
         if (!contentMatchesFocus(content, focus))
             continue;
-        chunks.push(content);
+        chunks.push({
+            content,
+            source: toFileReference(logPath),
+            path: toPosixPath(path.basename(logPath)),
+        });
     }
-    return joinMergedContent(chunks);
+    return joinMergedWithSources(chunks);
 };
-const collectFocusedZipContents = (entries, paths, basePath, focus) => {
+const collectFocusedZipContents = (entries, paths, basePath, focus, sourceRef) => {
     const normalizedBasePath = normalizeLowerPath(basePath);
     const candidatePaths = sortLogPaths(paths.filter((entryPath) => {
         const normalizedPath = toPosixPath(entryPath);
@@ -209,23 +248,39 @@ const collectFocusedZipContents = (entries, paths, basePath, focus) => {
         const content = decodeNodeBytes(bytes);
         if (!contentMatchesFocus(content, focus))
             continue;
-        chunks.push(content);
+        chunks.push({
+            content,
+            source: toZipReference(sourceRef, toPosixPath(entryPath)),
+            path: toPosixPath(entryPath),
+        });
     }
-    return joinMergedContent(chunks);
+    return joinMergedWithSources(chunks);
 };
-const buildDefaultZipContent = (entries, paths, basePath) => {
+const buildDefaultZipContent = (entries, paths, basePath, sourceRef) => {
     const bakLogName = BAK_LOG_NAMES.find((name) => findZipEntry(entries, paths, joinPath(basePath, name)));
     const mainLogName = MAIN_LOG_NAMES.find((name) => findZipEntry(entries, paths, joinPath(basePath, name)));
-    const bakData = bakLogName ? findZipEntry(entries, paths, joinPath(basePath, bakLogName)) : null;
-    const mainData = mainLogName ? findZipEntry(entries, paths, joinPath(basePath, mainLogName)) : null;
     const chunks = [];
-    if (bakData) {
-        chunks.push(decodeNodeBytes(bakData));
+    if (bakLogName) {
+        const data = findZipEntry(entries, paths, joinPath(basePath, bakLogName));
+        if (data) {
+            chunks.push({
+                content: decodeNodeBytes(data),
+                source: toZipReference(sourceRef, joinPath(basePath, bakLogName)),
+                path: toPosixPath(joinPath(basePath, bakLogName)),
+            });
+        }
     }
-    if (mainData) {
-        chunks.push(decodeNodeBytes(mainData));
+    if (mainLogName) {
+        const data = findZipEntry(entries, paths, joinPath(basePath, mainLogName));
+        if (data) {
+            chunks.push({
+                content: decodeNodeBytes(data),
+                source: toZipReference(sourceRef, joinPath(basePath, mainLogName)),
+                path: toPosixPath(joinPath(basePath, mainLogName)),
+            });
+        }
     }
-    return joinMergedContent(chunks);
+    return joinMergedWithSources(chunks);
 };
 export const readNodeTextFileContent = async (filePath) => {
     const bytes = await readFile(filePath);
@@ -239,10 +294,10 @@ export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip
     const basePath = findBaseDirectory(paths);
     if (basePath == null)
         return null;
-    const content = options.focus
-        ? collectFocusedZipContents(files, paths, basePath, options.focus)
-        : buildDefaultZipContent(files, paths, basePath);
-    if (!content)
+    const merged = options.focus
+        ? collectFocusedZipContents(files, paths, basePath, options.focus, sourceRef)
+        : buildDefaultZipContent(files, paths, basePath, sourceRef);
+    if (!merged.content)
         return null;
     const errorImages = new Map();
     const visionImages = new Map();
@@ -285,7 +340,7 @@ export const extractZipContentFromNodeBuffer = (zipData, sourceRef = 'memory.zip
         });
     }
     textFiles.sort((a, b) => a.path.localeCompare(b.path));
-    return { content, errorImages, visionImages, waitFreezesImages, textFiles };
+    return { content: merged.content, sourceSegments: merged.segments, errorImages, visionImages, waitFreezesImages, textFiles };
 };
 export const extractZipContentFromNodeFile = async (zipFilePath, options = {}) => {
     const bytes = await readFile(zipFilePath);
@@ -368,22 +423,30 @@ const buildDefaultDirectoryContent = async (debugPath, allFiles) => {
     const mainLogPath = await pickPrimaryLogPath(debugPath, allFiles, MAIN_LOG_NAMES);
     const chunks = [];
     if (bakLogPath) {
-        chunks.push(await readNodeTextFileContent(bakLogPath));
+        chunks.push({
+            content: await readNodeTextFileContent(bakLogPath),
+            source: toFileReference(bakLogPath),
+            path: toPosixPath(path.relative(debugPath, bakLogPath)),
+        });
     }
     if (mainLogPath) {
-        chunks.push(await readNodeTextFileContent(mainLogPath));
+        chunks.push({
+            content: await readNodeTextFileContent(mainLogPath),
+            source: toFileReference(mainLogPath),
+            path: toPosixPath(path.relative(debugPath, mainLogPath)),
+        });
     }
-    return joinMergedContent(chunks);
+    return joinMergedWithSources(chunks);
 };
 export const loadNodeLogDirectory = async (inputDirectoryPath, options = {}) => {
     const debugPath = await resolveDebugDirectory(inputDirectoryPath);
     if (!debugPath)
         return null;
     const allFiles = await collectFilesRecursively(debugPath);
-    const content = options.focus
+    const merged = options.focus
         ? await collectFocusedFileContents(allFiles.filter((filePath) => isCoreLogName(path.basename(filePath))), options.focus)
         : await buildDefaultDirectoryContent(debugPath, allFiles);
-    if (!content)
+    if (!merged.content)
         return null;
     const errorImages = new Map();
     const visionImages = new Map();
@@ -422,7 +485,8 @@ export const loadNodeLogDirectory = async (inputDirectoryPath, options = {}) =>
     }
     textFiles.sort((a, b) => a.path.localeCompare(b.path));
     return {
-        content,
+        content: merged.content,
+        sourceSegments: merged.segments,
         errorImages,
         visionImages,
         waitFreezesImages,

package/dist/runtimeInspection.d.ts

@@ -0,0 +1,225 @@
+import type { KernelOutput, TaskInfo } from '@windsland52/maa-log-kernel';
+import type { FrameworkSession, FrameworkSessionExtraction } from './frameworkVersion.js';
+export declare const MLA_RUNTIME_INSPECTION_SCHEMA_VERSION = "mla-runtime-inspection/v1";
+export interface RuntimeEvidencePosition {
+    timestamp: string | null;
+    parserInputLine: number | null;
+    source: string | null;
+    path: string | null;
+    localLine: number | null;
+}
+export interface SourceSegment {
+    source: string;
+    path: string;
+    startLine: number;
+    lineCount: number;
+}
+interface RuntimeScope {
+    sessionId: string | null;
+    executionId: string;
+    taskId: number;
+    taskName: string;
+}
+export interface RuntimeFailure extends RuntimeScope {
+    failureId: string;
+    kind: 'next_list_timeout' | 'action_failed';
+    nodeId: number;
+    nodeName: string;
+    startedAt: string;
+    endedAt: string | null;
+    errorImages: string[];
+    visionImages: string[];
+    evidence: RuntimeEvidencePosition;
+}
+export interface RuntimeOutcome extends RuntimeScope {
+    outcomeId: string;
+    kind: 'pipeline_node' | 'task';
+    status: 'failed' | 'running';
+    nodeId: number | null;
+    nodeName: string | null;
+    directFailureIds: string[];
+    evidence: RuntimeEvidencePosition;
+}
+export interface RuntimeMetricDistribution {
+    count: number;
+    minimum: number;
+    p50: number;
+    p95: number;
+    maximum: number;
+    average: number;
+}
+export type RuntimeSignalPriority = 'high' | 'normal' | 'low';
+export type RuntimeSignalPriorityReason = 'timeout' | 'unmatched_terminal' | 'high_mixed_results' | 'high_unsuccessful_attempts' | 'high_occurrence_count' | 'related_to_direct_failure' | 'still_repeating_at_log_end' | 'high_repeat_count' | 'long_duration' | 'incomplete_repetition';
+export interface RecognitionOccurrenceSample {
+    nodeId: number;
+    startedAt: string;
+    endedAt: string | null;
+    attemptCount: number;
+    unsuccessfulAttempts: number;
+    terminalMatch: string | null;
+    evidence: {
+        start: RuntimeEvidencePosition;
+        end: RuntimeEvidencePosition;
+    };
+}
+export interface RecognitionActivitySignal extends RuntimeScope {
+    signalId: string;
+    kind: 'recognition_activity';
+    pipelineNodeName: string;
+    nextList: {
+        name: string;
+        anchor: boolean;
+        jumpBack: boolean;
+    }[];
+    occurrenceCount: number;
+    occurrencesWithMixedResults: number;
+    terminalOutcomes: {
+        matched: number;
+        timeout: number;
+        running: number;
+        unmatched: number;
+    };
+    terminalMatches: {
+        name: string;
+        count: number;
+    }[];
+    candidateStatistics: {
+        name: string;
+        evaluationCount: number;
+        matchedAttemptCount: number;
+        unsuccessfulAttemptCount: number;
+        runningAttemptCount: number;
+        terminalMatchCount: number;
+    }[];
+    unmappedAttemptCount: number;
+    attempts: RuntimeMetricDistribution;
+    unsuccessfulAttempts: RuntimeMetricDistribution;
+    durationMs: RuntimeMetricDistribution;
+    representatives: {
+        first: RecognitionOccurrenceSample;
+        worst: RecognitionOccurrenceSample;
+        last: RecognitionOccurrenceSample;
+    };
+    priority: RuntimeSignalPriority;
+    priorityReasons: RuntimeSignalPriorityReason[];
+}
+export interface RepeatedNodeSequenceSignal extends RuntimeScope {
+    signalId: string;
+    kind: 'repeated_node' | 'repeated_node_cycle';
+    pattern: string[];
+    segmentCount: number;
+    totalRepeatCount: number;
+    maximumRepeatCount: number;
+    durationMs: RuntimeMetricDistribution;
+    terminations: {
+        leftPattern: number;
+        taskEnded: number;
+        stillRepeatingAtLogEnd: number;
+    };
+    representatives: {
+        first: {
+            firstSeenAt: string;
+            lastSeenAt: string;
+            repeatCount: number;
+            evidence: RuntimeEvidencePosition;
+        };
+        longest: {
+            firstSeenAt: string;
+            lastSeenAt: string;
+            repeatCount: number;
+            evidence: RuntimeEvidencePosition;
+        };
+        last: {
+            firstSeenAt: string;
+            lastSeenAt: string;
+            repeatCount: number;
+            evidence: RuntimeEvidencePosition;
+        };
+    };
+    detector: {
+        name: 'repeated-completed-node-sequence';
+        version: 1;
+        minimumRepeats: number;
+        maximumPatternLength: 8;
+    };
+    priority: RuntimeSignalPriority;
+    priorityReasons: RuntimeSignalPriorityReason[];
+}
+export type RuntimeSignal = RecognitionActivitySignal | RepeatedNodeSequenceSignal;
+export interface RuntimeTaskStatistics {
+    nodeExecutions: number;
+    succeededNodes: number;
+    failedNodes: number;
+    runningNodes: number;
+    recognitionAttempts: number;
+    unsuccessfulRecognitionAttempts: number;
+    nodeExecutionsWithRecognition: number;
+    nodeExecutionsWithMixedRecognitionResults: number;
+    recognitionActivityGroups: number;
+    maximumRecognitionAttemptsPerNode: number;
+    maximumUnsuccessfulRecognitionAttemptsPerNode: number;
+    actionAttempts: number;
+    actionFailures: number;
+    nextListTimeouts: number;
+    errorImageReferences: number;
+    uniqueErrorImages: number;
+    visionImageReferences: number;
+    uniqueVisionImages: number;
+}
+export interface RuntimeTaskExecution {
+    executionId: string;
+    taskId: number;
+    name: string;
+    hash: string;
+    uuid: string;
+    status: TaskInfo['status'];
+    completeness: 'complete' | 'open_at_log_end';
+    startedAt: string;
+    endedAt: string | null;
+    observedDurationMs: number | null;
+    firstNode: string | null;
+    lastNode: string | null;
+    statistics: RuntimeTaskStatistics;
+    directFailureIds: string[];
+    outcomeIds: string[];
+    signalIds: string[];
+    signalHighlights: {
+        recognitionActivity: string[];
+        repetitions: string[];
+    };
+    evidence: {
+        start: RuntimeEvidencePosition;
+        end: RuntimeEvidencePosition;
+    };
+}
+export interface RuntimeSession {
+    sessionId: string;
+    startKind: FrameworkSession['startKind'];
+    frameworkStatus: FrameworkSession['status'];
+    frameworkVersion: string | null;
+    versions: string[];
+    start: FrameworkSession['start'];
+    end: FrameworkSession['end'];
+    tasks: RuntimeTaskExecution[];
+    summary: {
+        taskExecutions: number;
+        succeededTasks: number;
+        failedTasks: number;
+        runningTasks: number;
+        directFailures: number;
+        nextListTimeouts: number;
+        actionFailures: number;
+        signals: number;
+    };
+}
+export interface RuntimeInspection {
+    schemaVersion: typeof MLA_RUNTIME_INSPECTION_SCHEMA_VERSION;
+    sessions: RuntimeSession[];
+    unscopedTasks: RuntimeTaskExecution[];
+    failures: RuntimeFailure[];
+    outcomes: RuntimeOutcome[];
+    signals: RuntimeSignal[];
+    warnings: string[];
+}
+export declare const buildRuntimeInspection: (output: KernelOutput, framework: FrameworkSessionExtraction, sourceSegments?: readonly SourceSegment[]) => RuntimeInspection;
+export {};

package/dist/runtimeInspection.js

@@ -0,0 +1,582 @@
+import { buildNodeExecutionTimeline } from './nodeExecutionTimeline.js';
+export const MLA_RUNTIME_INSPECTION_SCHEMA_VERSION = 'mla-runtime-inspection/v1';
+const timestampMs = (value) => {
+    if (!value)
+        return null;
+    const parsed = Date.parse(value.includes('T') ? value : value.replace(' ', 'T'));
+    return Number.isFinite(parsed) ? parsed : null;
+};
+const elapsed = (start, end) => {
+    const startMs = timestampMs(start);
+    const endMs = timestampMs(end);
+    return startMs == null || endMs == null ? null : Math.max(0, endMs - startMs);
+};
+const buildEvidenceIndex = (task) => {
+    const exactLines = new Map();
+    const ordered = [];
+    for (const event of task.events) {
+        if (event._lineNumber == null)
+            continue;
+        if (!exactLines.has(event.timestamp))
+            exactLines.set(event.timestamp, event._lineNumber);
+        const timestamp = timestampMs(event.timestamp);
+        if (timestamp != null)
+            ordered.push({ timestamp, line: event._lineNumber });
+    }
+    ordered.sort((left, right) => left.timestamp - right.timestamp);
+    return { exactLines, ordered };
+};
+const evidence = (index, timestamp) => {
+    if (timestamp) {
+        const exactLine = index.exactLines.get(timestamp);
+        if (exactLine != null)
+            return { timestamp, parserInputLine: exactLine, source: null, path: null, localLine: null };
+    }
+    const target = timestampMs(timestamp);
+    if (target == null || index.ordered.length === 0) {
+        return { timestamp: timestamp ?? null, parserInputLine: null, source: null, path: null, localLine: null };
+    }
+    let low = 0;
+    let high = index.ordered.length;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if ((index.ordered[middle]?.timestamp ?? target) < target)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    const before = index.ordered[low - 1];
+    const after = index.ordered[low];
+    const nearest = before == null
+        ? after
+        : after == null || target - before.timestamp <= after.timestamp - target ? before : after;
+    return { timestamp: timestamp ?? null, parserInputLine: nearest?.line ?? null, source: null, path: null, localLine: null };
+};
+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)]
+            .filter((item) => Boolean(item)),
+        vision: attempts.map(item => item.vision_image).filter((item) => Boolean(item)),
+    };
+};
+const scopeFor = (task, sessionId, executionId) => ({
+    sessionId,
+    executionId,
+    taskId: task.task_id,
+    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');
+    if (complete.length === 1)
+        return complete[0] ?? null;
+    const partial = candidates.filter(session => session.startKind === 'partial_file');
+    return complete.length === 0 && partial.length === 1 ? (partial[0] ?? null) : null;
+};
+const metricDistribution = (values) => {
+    if (values.length === 0) {
+        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 total = sorted.reduce((sum, value) => sum + value, 0);
+    return {
+        count: sorted.length,
+        minimum: sorted[0] ?? 0,
+        p50: percentile(0.5),
+        p95: percentile(0.95),
+        maximum: sorted[sorted.length - 1] ?? 0,
+        average: total / sorted.length,
+    };
+};
+const recognitionCandidateName = (attempt, nextNames) => {
+    if (attempt.anchor_name && nextNames.has(attempt.anchor_name))
+        return attempt.anchor_name;
+    if (nextNames.has(attempt.name))
+        return attempt.name;
+    const detailName = attempt.reco_details?.name;
+    return detailName && nextNames.has(detailName) ? detailName : null;
+};
+const increment = (map, key) => {
+    map.set(key, (map.get(key) ?? 0) + 1);
+};
+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')) {
+        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')) {
+        return { priority: 'normal', priorityReasons: reasons };
+    }
+    return { priority: 'low', priorityReasons: reasons };
+};
+const repetitions = (nodes) => {
+    const result = [];
+    let start = 0;
+    while (start < nodes.length) {
+        let best = null;
+        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);
+                if (!same)
+                    break;
+                count += 1;
+            }
+            if (count < (length === 1 ? 5 : 3))
+                continue;
+            if (best == null || length * count > best.length * best.count)
+                best = { start, length, count };
+        }
+        if (best == null)
+            start += 1;
+        else {
+            result.push(best);
+            start += best.length * best.count;
+        }
+    }
+    return result;
+};
+const canonicalCycle = (pattern) => {
+    if (pattern.length < 2)
+        return [...pattern];
+    const rotations = pattern.map((_, index) => [...pattern.slice(index), ...pattern.slice(0, index)]);
+    rotations.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    return rotations[0] ?? [...pattern];
+};
+const findSourceSegment = (segments, parserInputLine) => {
+    for (const segment of segments) {
+        if (parserInputLine >= segment.startLine && parserInputLine < segment.startLine + segment.lineCount) {
+            return segment;
+        }
+    }
+    return null;
+};
+const enrichWithSource = (position, segments) => {
+    if (!segments || position.parserInputLine == null)
+        return position;
+    const segment = findSourceSegment(segments, position.parserInputLine);
+    if (!segment)
+        return position;
+    return {
+        ...position,
+        source: segment.source,
+        path: segment.path,
+        localLine: position.parserInputLine - segment.startLine + 1,
+    };
+};
+const createEvidenceFn = (segments) => (index, timestamp) => enrichWithSource(evidence(index, timestamp), segments);
+export const buildRuntimeInspection = (output, framework, sourceSegments) => {
+    const failures = [];
+    const outcomes = [];
+    const signals = [];
+    const taskOccurrences = new Map();
+    const executionIds = new Map();
+    const sessionIds = new Map();
+    const executionSessionIds = new Map();
+    const evidenceAt = createEvidenceFn(sourceSegments);
+    for (const task of output.tasks) {
+        const occurrence = (taskOccurrences.get(task.task_id) ?? 0) + 1;
+        taskOccurrences.set(task.task_id, occurrence);
+        const executionId = `task-execution-${task.task_id}-${occurrence}`;
+        const sessionId = sessionFor(task, framework.sessions)?.sessionId ?? null;
+        executionIds.set(task, executionId);
+        sessionIds.set(task, sessionId);
+        executionSessionIds.set(executionId, sessionId);
+    }
+    const buildTask = (task) => {
+        const sessionId = sessionIds.get(task) ?? null;
+        const executionId = executionIds.get(task);
+        if (!executionId)
+            throw new Error('Task execution identity was not initialized.');
+        const scope = scopeFor(task, sessionId, executionId);
+        const directFailureIds = [];
+        const outcomeIds = [];
+        const signalIds = [];
+        const recognitionOccurrences = [];
+        const evidenceIndex = buildEvidenceIndex(task);
+        const timeline = buildNodeExecutionTimeline(task.nodes, { rootTaskId: task.task_id });
+        for (const item of timeline) {
+            const failureKind = item.navStatus === 'action-failed'
+                ? 'action_failed'
+                : item.navStatus === 'timeout' && item.nodeInfo.next_list.length > 0
+                    ? 'next_list_timeout'
+                    : null;
+            let nodeFailureId = null;
+            if (failureKind) {
+                nodeFailureId = `failure-${failures.length + 1}`;
+                const images = imagesFor(item.nodeInfo);
+                failures.push({
+                    ...scope,
+                    failureId: nodeFailureId,
+                    kind: failureKind,
+                    nodeId: item.nodeInfo.node_id,
+                    nodeName: item.executionName,
+                    startedAt: item.nodeInfo.ts,
+                    endedAt: item.nodeInfo.end_ts ?? null,
+                    errorImages: [...new Set(images.error)],
+                    visionImages: [...new Set(images.vision)],
+                    evidence: evidenceAt(evidenceIndex, item.nodeInfo.end_ts ?? item.nodeInfo.ts),
+                });
+                directFailureIds.push(nodeFailureId);
+            }
+            if (item.nodeInfo.status !== 'success') {
+                const outcomeId = `outcome-${outcomes.length + 1}`;
+                outcomes.push({
+                    ...scope,
+                    outcomeId,
+                    kind: 'pipeline_node',
+                    status: item.nodeInfo.status,
+                    nodeId: item.nodeInfo.node_id,
+                    nodeName: item.executionName,
+                    directFailureIds: nodeFailureId ? [nodeFailureId] : [],
+                    evidence: evidenceAt(evidenceIndex, item.nodeInfo.end_ts ?? item.nodeInfo.ts),
+                });
+                outcomeIds.push(outcomeId);
+            }
+            const attempts = recognitionItems(item.nodeInfo.node_flow);
+            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';
+                recognitionOccurrences.push({
+                    nodeId: item.nodeInfo.node_id,
+                    pipelineNodeName: item.nodeInfo.name,
+                    nextList: item.nodeInfo.next_list.map(next => ({
+                        name: next.name,
+                        anchor: next.anchor,
+                        jumpBack: next.jump_back,
+                    })),
+                    attempts,
+                    terminalMatch: item.matchedRecognitionName ?? null,
+                    terminalOutcome,
+                    durationMs: elapsed(item.nodeInfo.ts, item.nodeInfo.end_ts),
+                    sample: {
+                        nodeId: item.nodeInfo.node_id,
+                        startedAt: item.nodeInfo.ts,
+                        endedAt: item.nodeInfo.end_ts ?? null,
+                        attemptCount: attempts.length,
+                        unsuccessfulAttempts: missed.length,
+                        terminalMatch: item.matchedRecognitionName ?? null,
+                        evidence: {
+                            start: evidenceAt(evidenceIndex, attempts[0]?.ts ?? item.nodeInfo.ts),
+                            end: evidenceAt(evidenceIndex, item.nodeInfo.end_ts ?? item.nodeInfo.ts),
+                        },
+                    },
+                });
+            }
+        }
+        const recognitionGroups = new Map();
+        for (const occurrence of recognitionOccurrences) {
+            const key = JSON.stringify([occurrence.pipelineNodeName, occurrence.nextList]);
+            const group = recognitionGroups.get(key) ?? [];
+            group.push(occurrence);
+            recognitionGroups.set(key, group);
+        }
+        for (const group of recognitionGroups.values()) {
+            const firstOccurrence = group[0];
+            const lastOccurrence = group[group.length - 1];
+            if (!firstOccurrence || !lastOccurrence)
+                continue;
+            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, {
+                    name: next.name,
+                    evaluationCount: 0,
+                    matchedAttemptCount: 0,
+                    unsuccessfulAttemptCount: 0,
+                    runningAttemptCount: 0,
+                    terminalMatchCount: 0,
+                }]));
+            let unmappedAttemptCount = 0;
+            let occurrencesWithMixedResults = 0;
+            for (const occurrence of group) {
+                terminalOutcomes[occurrence.terminalOutcome] += 1;
+                if (occurrence.terminalMatch) {
+                    increment(terminalMatches, occurrence.terminalMatch);
+                    const candidate = candidates.get(occurrence.terminalMatch);
+                    if (candidate)
+                        candidate.terminalMatchCount += 1;
+                }
+                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());
+                for (const attempt of occurrence.attempts) {
+                    const candidateName = recognitionCandidateName(attempt, nextNames);
+                    const candidate = candidateName ? candidates.get(candidateName) : null;
+                    if (!candidate) {
+                        unmappedAttemptCount += 1;
+                        continue;
+                    }
+                    candidate.evaluationCount += 1;
+                    if (attempt.status === 'success')
+                        candidate.matchedAttemptCount += 1;
+                    else if (attempt.status === 'failed')
+                        candidate.unsuccessfulAttemptCount += 1;
+                    else
+                        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 reasons = [];
+            if (terminalOutcomes.timeout > 0)
+                reasons.push('timeout');
+            if (terminalOutcomes.unmatched > 0)
+                reasons.push('unmatched_terminal');
+            if (group.length > 0 && occurrencesWithMixedResults / group.length >= 0.3)
+                reasons.push('high_mixed_results');
+            if (unsuccessfulDist.maximum >= 5 || unsuccessfulDist.p95 >= 3)
+                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))) {
+                reasons.push('related_to_direct_failure');
+            }
+            const ranking = prioritize(reasons);
+            signals.push({
+                ...scope,
+                signalId,
+                kind: 'recognition_activity',
+                pipelineNodeName: firstOccurrence.pipelineNodeName,
+                nextList: firstOccurrence.nextList,
+                occurrenceCount: group.length,
+                occurrencesWithMixedResults,
+                terminalOutcomes,
+                terminalMatches: [...terminalMatches].map(([name, count]) => ({ name, count }))
+                    .sort((left, right) => right.count - left.count),
+                candidateStatistics: [...candidates.values()],
+                unmappedAttemptCount,
+                attempts: attemptsDist,
+                unsuccessfulAttempts: unsuccessfulDist,
+                durationMs: durationDist,
+                representatives: {
+                    first: firstOccurrence.sample,
+                    worst: worstOccurrence.sample,
+                    last: lastOccurrence.sample,
+                },
+                priority: ranking.priority,
+                priorityReasons: ranking.priorityReasons,
+            });
+            signalIds.push(signalId);
+        }
+        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];
+            const lastIndex = repeated.start + repeated.length * repeated.count - 1;
+            const last = completed[lastIndex];
+            if (!first || !last)
+                continue;
+            const reachesEnd = lastIndex === completed.length - 1;
+            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) ?? [];
+            group.push({
+                pattern,
+                repeatCount: repeated.count,
+                durationMs: elapsed(first.ts, last.end_ts ?? last.ts) ?? 0,
+                firstSeenAt: first.ts,
+                lastSeenAt: last.end_ts ?? last.ts,
+                termination: reachesEnd
+                    ? task.status === 'running' ? 'still_repeating_at_log_end' : 'task_ended'
+                    : 'left_pattern',
+                evidence: evidenceAt(evidenceIndex, first.ts),
+            });
+            repetitionGroups.set(key, group);
+        }
+        for (const group of repetitionGroups.values()) {
+            const first = group[0];
+            const last = group[group.length - 1];
+            if (!first || !last)
+                continue;
+            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,
+            };
+            const totalRepeatCount = group.reduce((sum, item) => sum + item.repeatCount, 0);
+            const maximumRepeatCount = Math.max(...group.map(item => item.repeatCount));
+            const repetitionReasons = [];
+            if (terminations.leftPattern > 0)
+                repetitionReasons.push('incomplete_repetition');
+            if (terminations.stillRepeatingAtLogEnd > 0)
+                repetitionReasons.push('still_repeating_at_log_end');
+            if (maximumRepeatCount >= 10 || totalRepeatCount >= 20)
+                repetitionReasons.push('high_repeat_count');
+            const repetitionRanking = prioritize(repetitionReasons);
+            signals.push({
+                ...scope,
+                signalId,
+                kind: first.pattern.length === 1 ? 'repeated_node' : 'repeated_node_cycle',
+                pattern: first.pattern,
+                segmentCount: group.length,
+                totalRepeatCount,
+                maximumRepeatCount,
+                durationMs: metricDistribution(group.map(item => item.durationMs)),
+                terminations,
+                representatives: {
+                    first: first,
+                    longest,
+                    last,
+                },
+                detector: {
+                    name: 'repeated-completed-node-sequence',
+                    version: 1,
+                    minimumRepeats: first.pattern.length === 1 ? 5 : 3,
+                    maximumPatternLength: 8,
+                },
+                priority: repetitionRanking.priority,
+                priorityReasons: repetitionRanking.priorityReasons,
+            });
+            signalIds.push(signalId);
+        }
+        if (task.status !== 'succeeded') {
+            const outcomeId = `outcome-${outcomes.length + 1}`;
+            outcomes.push({
+                ...scope,
+                outcomeId,
+                kind: 'task',
+                status: task.status,
+                nodeId: null,
+                nodeName: null,
+                directFailureIds: [...directFailureIds],
+                evidence: evidenceAt(evidenceIndex, task.end_time ?? task.events[task.events.length - 1]?.timestamp),
+            });
+            outcomeIds.push(outcomeId);
+        }
+        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 recognitionActivity = ownSignals
+            .filter((signal) => (signal.kind === 'recognition_activity'))
+            .sort((left, right) => (right.unsuccessfulAttempts.maximum - left.unsuccessfulAttempts.maximum
+            || right.occurrenceCount - left.occurrenceCount))
+            .slice(0, 5)
+            .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))
+            .slice(0, 5)
+            .map(signal => signal.signalId);
+        return {
+            executionId: scope.executionId,
+            taskId: task.task_id,
+            name: task.entry,
+            hash: task.hash,
+            uuid: task.uuid,
+            status: task.status,
+            completeness: task.status === 'running' ? 'open_at_log_end' : 'complete',
+            startedAt: task.start_time,
+            endedAt: task.end_time ?? null,
+            observedDurationMs: task.duration ?? elapsed(task.start_time, task.end_time),
+            firstNode: timeline[0]?.executionName ?? null,
+            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,
+                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));
+                    return statuses.has('failed') && statuses.has('success');
+                }).length,
+                recognitionActivityGroups: recognitionActivity.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,
+                uniqueVisionImages: new Set(visionImages).size,
+            },
+            directFailureIds,
+            outcomeIds,
+            signalIds,
+            signalHighlights: { recognitionActivity, repetitions: repetitionSignals },
+            evidence: {
+                start: evidenceAt(evidenceIndex, task.start_time),
+                end: evidenceAt(evidenceIndex, task.end_time ?? task.events[task.events.length - 1]?.timestamp),
+            },
+        };
+    };
+    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));
+        return {
+            sessionId: session.sessionId,
+            startKind: session.startKind,
+            frameworkStatus: session.status,
+            frameworkVersion: session.version,
+            versions: [...session.versions],
+            start: session.start,
+            end: session.end,
+            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,
+                directFailures: scopedFailures.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);
+    return {
+        schemaVersion: MLA_RUNTIME_INSPECTION_SCHEMA_VERSION,
+        sessions,
+        unscopedTasks,
+        failures,
+        outcomes,
+        signals,
+        warnings: [
+            ...framework.warnings,
+            ...(unscopedTasks.length
+                ? [`${unscopedTasks.length} task execution(s) could not be assigned to one runtime session.`]
+                : []),
+        ],
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windsland52/maa-log-tools",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "type": "module",
   "private": false,
   "bin": {
@@ -42,10 +42,10 @@
   },
   "dependencies": {
     "fflate": "^0.8.2",
-    "@windsland52/maa-log-kernel": "1.0.0",
-    "@windsland52/maa-log-parser": "1.0.0",
-    "@windsland52/maa-log-runtime": "1.0.0",
-    "@windsland52/maa-log-adapter": "1.0.0"
+    "@windsland52/maa-log-adapter": "1.0.1",
+    "@windsland52/maa-log-parser": "1.0.1",
+    "@windsland52/maa-log-runtime": "1.0.1",
+    "@windsland52/maa-log-kernel": "1.0.1"
   },
   "engines": {
     "node": ">=24.0.0"