rea-agents 6.4.0 → 6.7.0

package/dist/adb/AdbShellOutput.js

@@ -1,10 +1,3 @@
-/**
- * Parsers for fixed observation commands REA runs through `adb shell`.
- *
- * Formats follow toybox output on Android 8+ (verified against an Android 14
- * emulator). Unparseable lines are retained rather than dropped so callers
- * can see the format drift instead of silently losing rows.
- */
 const PROCESS_LINE = /^(\S+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(.+)$/u;
 /** Parse `ps -A` output; the header line is preserved verbatim as `columns`. */
 export const parseProcessListOutput = (stdout) => {
@@ -35,48 +28,6 @@ export const parseProcessListOutput = (stdout) => {
     }
     return { columns, processes, unparsedLines };
 };
-const LS_LINE = /^([bcdlps-][rwxstST-]{9})\s+(?:(\d+)\s+)?(\S+)\s+(\S+)\s+(?:(\d+)\s+)?([\d-]{10})\s+([\d:]{4,8})\s+(.+)$/u;
-/** Parse `ls -la` output, including `total` headers and symlink targets. */
-export const parseLsOutput = (stdout) => {
-    const entries = [];
-    const unparsedLines = [];
-    for (const rawLine of stdout.split(/\r?\n/u)) {
-        const line = rawLine.trimEnd();
-        if (line === "" || line.startsWith("total "))
-            continue;
-        const match = LS_LINE.exec(line);
-        if (match === null) {
-            if (line.trim() !== "")
-                unparsedLines.push(line);
-            continue;
-        }
-        const permissions = match[1];
-        let name = match[8].trim();
-        let linkTarget = null;
-        const linkArrow = name.indexOf(" -> ");
-        if (linkArrow !== -1 && permissions.startsWith("l")) {
-            linkTarget = name.slice(linkArrow + 4);
-            name = name.slice(0, linkArrow);
-        }
-        entries.push({
-            name,
-            kind: permissions.startsWith("d")
-                ? "directory"
-                : permissions.startsWith("l")
-                    ? "symlink"
-                    : permissions.startsWith("-")
-                        ? "file"
-                        : "other",
-            permissions,
-            owner: match[3] ?? null,
-            group: match[4] ?? null,
-            bytes: match[5] === undefined ? null : Number(match[5]),
-            date: `${match[6] ?? ""} ${match[7] ?? ""}`.trim() || null,
-            link_target: linkTarget,
-        });
-    }
-    return { entries, unparsedLines };
-};
 const FEATURE_LINE = /^feature:([^=\s]+)(?:=(0x[0-9a-fA-F]+|\d+))?$/u;
 const parseFeatureVersion = (text) => text.startsWith("0x") ? Number.parseInt(text.slice(2), 16) : Number(text);
 /** Parse `pm list features` output, including hex GL versions. */
@@ -125,6 +76,7 @@ const SIZE_PAIR = /^Physical size:\s+(\d+)x(\d+)$/u;
 const SIZE_OVERRIDE = /^Override size:\s+(\d+)x(\d+)$/u;
 const DENSITY_PHYSICAL = /^Physical density:\s+(\d+)$/u;
 const DENSITY_OVERRIDE = /^Override density:\s+(\d+)$/u;
+const DENSITY_BARE = /^(\d+)$/u;
 /** Parse `wm size` output into physical and optional override sizes. */
 export const parseWmSizeOutput = (stdout) => {
     let physical = null;
@@ -146,10 +98,16 @@ export const parseWmSizeOutput = (stdout) => {
     }
     return { physical, override };
 };
-/** Parse `wm density` output. Older builds print a bare number. */
+/**
+ * Parse `wm density` output. Current builds print labeled physical and
+ * optional override lines; older builds print the physical density as a
+ * bare number on its own line (morluto/rea#3942). A labeled declaration
+ * wins over a bare one so a mixed dump cannot downgrade the physical value.
+ */
 export const parseWmDensityOutput = (stdout) => {
     let physical = null;
     let override = null;
+    let bare = null;
     for (const line of stdout.split(/\r?\n/u)) {
         const trimmed = line.trim();
         const physicalMatch = DENSITY_PHYSICAL.exec(trimmed);
@@ -158,21 +116,74 @@ export const parseWmDensityOutput = (stdout) => {
         const overrideMatch = DENSITY_OVERRIDE.exec(trimmed);
         if (overrideMatch !== null)
             override = Number(overrideMatch[1]);
+        const bareMatch = DENSITY_BARE.exec(trimmed);
+        if (bareMatch !== null && bare === null)
+            bare = Number(bareMatch[1]);
     }
-    return { physical, override };
+    return { physical: physical ?? bare, override };
 };
-/** Parse the focus declarations from `dumpsys window windows`. */
+/** Own declaration identity and omission before deriving a singular summary. */
 export const parseWindowFocusOutput = (stdout) => {
-    let focusedWindow = null;
-    let focusedApp = null;
+    const contexts = [];
+    const observedLines = [];
+    let current;
     for (const line of stdout.split(/\r?\n/u)) {
         const trimmed = line.trim();
-        if (focusedWindow === null && trimmed.startsWith("mCurrentFocus="))
-            focusedWindow = trimmed.slice("mCurrentFocus=".length).trim();
-        if (focusedApp === null && trimmed.startsWith("mFocusedApp="))
-            focusedApp = trimmed.slice("mFocusedApp=".length).trim();
+        if (trimmed.startsWith("Display:")) {
+            current = {
+                scope: "display",
+                display_id: /^Display:\s+mDisplayId=(-?[0-9]+)(?:\s|$)/u.exec(trimmed)?.[1] ??
+                    null,
+                header_line: line,
+                declarations: [],
+            };
+            contexts.push(current);
+            observedLines.push(line);
+            continue;
+        }
+        const field = trimmed.startsWith("mCurrentFocus=")
+            ? "mCurrentFocus"
+            : trimmed.startsWith("mFocusedApp=")
+                ? "mFocusedApp"
+                : undefined;
+        if (field === undefined)
+            continue;
+        if (current === undefined) {
+            current = {
+                scope: "unscoped",
+                display_id: null,
+                header_line: null,
+                declarations: [],
+            };
+            contexts.push(current);
+        }
+        const value = trimmed.slice(field.length + 1).trim();
+        current.declarations.push({
+            field,
+            value: value === "null" ? null : value,
+            raw_line: line,
+        });
+        observedLines.push(line);
     }
-    return { focusedWindow, focusedApp };
+    const windows = contexts.length === 1
+        ? contexts[0].declarations.filter(({ field }) => field === "mCurrentFocus")
+        : [];
+    const apps = contexts.length === 1
+        ? contexts[0].declarations.filter(({ field }) => field === "mFocusedApp")
+        : [];
+    const declared = contexts.some(({ declarations }) => declarations.length > 0);
+    const summary = !declared
+        ? "unavailable"
+        : contexts.length === 1 && windows.length <= 1 && apps.length <= 1
+            ? "single_context"
+            : "ambiguous";
+    return {
+        focused_window: summary === "single_context" ? (windows[0]?.value ?? null) : null,
+        focused_app: summary === "single_context" ? (apps[0]?.value ?? null) : null,
+        focus_summary: summary,
+        focus_contexts: contexts,
+        observed_lines: observedLines,
+    };
 };
 const DETAIL_LINE = /^\s+([A-Za-z][A-Za-z0-9_]*)=(.*)$/u;
 /**
@@ -191,13 +202,18 @@ export const parseDumpsysPackageOutput = (stdout) => {
         pkgFlags: null,
     };
     let inPermissions = false;
+    let hasPermissionsSection = false;
     let permissions = 0;
+    let parsedPackageAvailable = null;
     for (const line of stdout.split(/\r?\n/u)) {
         if (line.trim().startsWith("requested permissions:")) {
+            hasPermissionsSection = true;
             inPermissions = true;
             continue;
         }
-        if (inPermissions && /^\s{2,}[A-Za-z0-9._]+$/.test(line)) {
+        // Android 10 and 11 mark restricted entries as "NAME: restricted=true".
+        if (inPermissions &&
+            /^\s{2,}[A-Za-z0-9._]+(?:: restricted=true)?$/u.test(line)) {
             permissions += 1;
             continue;
         }
@@ -207,12 +223,18 @@ export const parseDumpsysPackageOutput = (stdout) => {
             continue;
         const key = match[1];
         const value = match[2].trim();
-        if (key === "versionName" && details.versionName === null)
+        if (key === "pkg" && parsedPackageAvailable === null) {
+            if (value === "null")
+                parsedPackageAvailable = false;
+            else if (value.startsWith("Package{") && value.endsWith("}"))
+                parsedPackageAvailable = true;
+        }
+        else if (key === "versionName" && details.versionName === null)
             details.versionName = value === "" ? null : value;
         else if (key === "versionCode" && details.versionCode === null) {
-            const parsed = /^(\d+)/u.exec(value);
+            const parsed = /^(-?\d+)/u.exec(value);
             if (parsed !== null)
-                details.versionCode = Number(parsed[1]);
+                details.versionCode = parsed[1];
         }
         else if (key === "firstInstallTime" && details.firstInstallTime === null)
             details.firstInstallTime = value === "" ? null : value;
@@ -229,7 +251,16 @@ export const parseDumpsysPackageOutput = (stdout) => {
         else if (key === "pkgFlags" && details.pkgFlags === null)
             details.pkgFlags = value === "" ? null : value;
     }
-    return { ...details, requestedPermissions: permissions };
+    // `dumpsys` omits this section both for known-empty inventories and when
+    // Package Manager has no parsed package; only the former is a known zero.
+    const requestedPermissions = parsedPackageAvailable === false
+        ? null
+        : hasPermissionsSection
+            ? permissions
+            : parsedPackageAvailable === true
+                ? 0
+                : null;
+    return { ...details, requestedPermissions };
 };
 /**
  * Parse `settings get` output. Android prints the literal string `null` for
@@ -246,6 +277,8 @@ export const parseBugreportCopiedPath = (stdout) => {
     const match = /^Bug report copied to (.+)\r?$/mu.exec(stdout.trim());
     return match === null ? null : match[1];
 };
+/** Read the device's `Failure [REASON]` verdict from package-change output. */
+export const packageChangeFailureReason = (output) => /Failure \[([^\]]+)\]/u.exec(output)?.[1] ?? null;
 /**
  * Parse `adb install`/`adb uninstall` output. adb can print `Failure [...]`
  * with a zero exit code, so the text decides, not the exit status.
@@ -254,10 +287,10 @@ export const parsePackageChangeOutput = (stdout) => {
     const text = stdout.trim();
     if (/^Success$/mu.test(text))
         return { status: "success", reason: null };
-    const failure = /Failure \[([^\]]+)\]/u.exec(text);
     return {
         status: "failure",
-        reason: failure?.[1] ?? (text === "" ? null : text.slice(0, 512)),
+        reason: packageChangeFailureReason(text) ??
+            (text === "" ? null : text.slice(0, 512)),
     };
 };
 /**
@@ -272,24 +305,60 @@ export const parseResolveActivityOutput = (stdout) => {
     return lines.length === 0 ? null : lines[lines.length - 1];
 };
 /**
- * Parse `am start` output. Success prints `Starting: Intent { ... }`;
- * refusals print lines starting with `Error:` or `Warning:` and activity
- * classes that do not exist name the component.
+ * Parse the complete `am start -W` report. `Starting:` records an attempt;
+ * hard errors and any non-ok Activity Manager status determine the verdict.
  */
-export const parseAmStartOutput = (stdout) => {
-    const text = stdout.trim();
-    const starting = /^Starting:\s+Intent\s*\{(.*)\}\s*$/mu.exec(text);
-    if (starting !== null)
+export const parseAmStartOutput = (stdout, stderr = "") => {
+    const normalizedStdout = stdout.replaceAll("\r\n", "\n");
+    const starting = /^Starting:[ \t]+Intent[ \t]*\{(.*)\}[ \t]*$/mu.exec(normalizedStdout);
+    const startedActivity = starting?.[1]?.trim() ?? null;
+    const activityMatch = /^Activity:[ \t]*(.*)$/mu.exec(normalizedStdout);
+    const activity = activityMatch?.[1]?.trim() || null;
+    const statuses = [...normalizedStdout.matchAll(/^Status:[ \t]*(.*)$/gmu)].map((match) => match[1].trim());
+    const nonOkStatus = statuses.find((status) => status.toLowerCase() !== "ok");
+    const reportedStatus = nonOkStatus ?? statuses[0] ?? null;
+    const error = [normalizedStdout, stderr.replaceAll("\r\n", "\n")]
+        .flatMap((stream) => stream.split("\n"))
+        .map((line) => line.trim())
+        .map((line) => ({
+        line,
+        match: /^(?:Error|Exception)(?::|\b)(.*)$/iu.exec(line),
+    }))
+        .find(({ match }) => match !== null);
+    const errorReason = error?.match?.[1]?.trim() || error?.line || null;
+    const statusReason = nonOkStatus === ""
+        ? "am start reported an empty status"
+        : nonOkStatus === undefined
+            ? null
+            : `am start reported status: ${nonOkStatus}`;
+    const reason = errorReason ??
+        statusReason ??
+        (/^Warning:/mu.test(normalizedStdout.trim())
+            ? normalizedStdout.trim().slice(0, 512)
+            : null);
+    if (errorReason !== null || nonOkStatus !== undefined)
+        return {
+            status: "refused",
+            startedActivity,
+            activity,
+            reportedStatus,
+            reason: reason ?? "am start did not report a successful launch",
+        };
+    if (startedActivity !== null)
         return {
             status: "started",
-            startedActivity: starting[1].trim(),
+            startedActivity,
+            activity,
+            reportedStatus,
             reason: null,
         };
-    const error = /^(?:Error|Warning|Exception)(?::|\b)(.*)$/mu.exec(text);
+    const text = `${normalizedStdout}\n${stderr.replaceAll("\r\n", "\n")}`.trim();
     return {
         status: "refused",
-        startedActivity: null,
-        reason: error?.[1]?.trim() ??
+        startedActivity,
+        activity,
+        reportedStatus,
+        reason: reason ??
             (text === "" ? "am start returned no activity" : text.slice(0, 512)),
     };
 };

package/dist/android/AndroidTargetSnapshot.js

@@ -4,13 +4,13 @@ import { join } from "node:path";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { AnalysisInputError, AnalysisCapabilityUnavailableError, } from "../domain/analysisErrorCore.js";
-import { openRegularFile, sameRegularFileState, } from "../filesystem/RegularFile.js";
+import { openRegularFile, assertRegularFileActive, sameRegularFileState, } from "../filesystem/RegularFile.js";
 /** Bind decompiler input to the admitted artifact, even if the original changes. */
 export const snapshotAndroidTarget = async (path, sha256, root, operation, signal) => {
     const snapshot = join(root, "target.apk");
     try {
         await copyAndroidSnapshot(path, snapshot, sha256, signal);
-        signal?.throwIfAborted();
+        assertRegularFileActive(signal);
         await chmod(snapshot, 0o400);
         return snapshot;
     }
@@ -31,7 +31,7 @@ export const snapshotAndroidEngine = async (source, sha256, root, operation, sig
     const path = join(root, "engine.jar");
     try {
         const observed = await copyAndroidSnapshot(source, path, sha256, signal);
-        signal?.throwIfAborted();
+        assertRegularFileActive(signal);
         await chmod(path, 0o400);
         return { path, sha256: observed };
     }
@@ -42,7 +42,7 @@ export const snapshotAndroidEngine = async (source, sha256, root, operation, sig
     }
 };
 const copyAndroidSnapshot = async (sourcePath, snapshotPath, expectedSha256, signal) => {
-    signal?.throwIfAborted();
+    assertRegularFileActive(signal);
     const source = await openRegularFile(sourcePath, {
         symlinks: "follow",
         signal,
@@ -55,7 +55,7 @@ const copyAndroidSnapshot = async (sourcePath, snapshotPath, expectedSha256, sig
     const hash = createHash("sha256");
     try {
         const initial = await source.stat();
-        signal?.throwIfAborted();
+        assertRegularFileActive(signal);
         const digest = new Transform({
             transform(chunk, _encoding, callback) {
                 copiedBytes += chunk.length;
@@ -69,7 +69,7 @@ const copyAndroidSnapshot = async (sourcePath, snapshotPath, expectedSha256, sig
         });
         try {
             destination = await open(snapshotPath, "wx", 0o600);
-            signal?.throwIfAborted();
+            assertRegularFileActive(signal);
             inputStream = source.createReadStream({
                 start: 0,
                 end: initial.size,
@@ -77,7 +77,7 @@ const copyAndroidSnapshot = async (sourcePath, snapshotPath, expectedSha256, sig
             });
             outputStream = destination.createWriteStream({ autoClose: false });
             await pipeline(inputStream, digest, outputStream, { signal });
-            signal?.throwIfAborted();
+            assertRegularFileActive(signal);
             await verifySourceState(source, sourcePath, initial, copiedBytes);
             const observedSha256 = hash.digest("hex");
             if (observedSha256 !== expectedSha256)

package/dist/android/JadxAnalysis.js

@@ -1,7 +1,6 @@
 import { androidResultSchemas } from "../domain/android/androidAnalysis.js";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
+import { AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
 import { jadxAppSchema, jadxClassPageSchema, jadxClassSchema, jadxLoadSchema, jadxMethodSchema, jadxXrefsSchema, normalizeJadxText, } from "./JadxProtocol.js";
-import { JADX_RELEASE } from "./JadxRelease.js";
 const methodsOf = (summary) => {
     const seen = new Map();
     return summary.methods.map((method) => {
@@ -12,7 +11,7 @@ const methodsOf = (summary) => {
             reported_signature: method.signature,
             overload_index: index,
             is_constructor: method.is_constructor,
-            dex_descriptor: null,
+            dex_descriptor: method.dex_descriptor,
         };
     });
 };
@@ -60,32 +59,44 @@ const inspectPackage = async (tools, loaded, engine) => {
     });
 };
 const searchClasses = async (tools, request, loaded, engine) => {
-    const classes = [];
+    const matches = [];
     const pageSize = 4096;
-    let total;
+    let offset = 0;
     do {
         const page = jadxClassPageSchema.parse(await tools.json("list_classes", {
-            offset: classes.length,
+            query: request.input.query,
+            offset,
             limit: pageSize,
         }));
-        if ((total !== undefined && total !== page.total) ||
-            page.offset !== classes.length ||
+        if (page.total_classes !== loaded.class_count ||
+            page.offset !== offset ||
             page.limit !== pageSize ||
-            page.items.length > pageSize)
+            page.next_offset < offset ||
+            page.next_offset > loaded.class_count ||
+            page.items.length > pageSize ||
+            page.items.length > page.next_offset - offset ||
+            (request.input.query === "" &&
+                page.items.length !== page.next_offset - offset) ||
+            page.items.some((name) => !name.includes(request.input.query)))
             throw new AnalysisOutputError(request.operation, "JADX class pagination changed identity or counts");
-        total = page.total;
-        classes.push(...page.items);
-        if (classes.length > total ||
-            (page.items.length === 0 && classes.length < total))
+        if ((offset < loaded.class_count && page.next_offset === offset) ||
+            (page.next_offset < loaded.class_count && page.items.length !== pageSize))
             throw new AnalysisOutputError(request.operation, "JADX class pagination is incomplete");
-    } while (classes.length < total);
-    if (new Set(classes).size !== classes.length || total !== loaded.class_count)
-        throw new AnalysisOutputError(request.operation, "JADX class inventory is duplicated or differs from the loaded class count");
+        matches.push(...page.items);
+        offset = page.next_offset;
+    } while (offset < loaded.class_count);
+    const occurrences = new Map();
+    for (const name of matches)
+        occurrences.set(name, (occurrences.get(name) ?? 0) + 1);
+    const duplicateNames = [...occurrences]
+        .filter(([, count]) => count > 1)
+        .map(([name, count]) => ({ name, occurrences: count }));
     return androidResultSchemas.search_android_classes.parse({
         engine,
         query: request.input.query,
-        total_classes: total,
-        matches: classes.filter((name) => name.includes(request.input.query)),
+        total_classes: loaded.class_count,
+        matches,
+        duplicate_names: duplicateNames,
         coverage: "complete",
     });
 };
@@ -100,8 +111,7 @@ const inspectMethod = async (tools, request, summary, engine) => {
     if (candidates.length > 1 && request.input.overload_index === undefined)
         inputFailure(request, "overload_index", `Select one of ${candidates.length} overloads: ${candidates.map((method) => `${method.overload_index}: ${method.reported_signature}`).join("; ")}`);
     const index = request.input.overload_index ?? 0;
-    const selected = candidates[index];
-    if (selected === undefined)
+    const selected = candidates[index] ??
         inputFailure(request, "overload_index", `Index ${index} is outside the ${candidates.length} matching overloads.`);
     const body = jadxMethodSchema.parse(await tools.json("get_method_body", {
         class_name: summary.full_name,
@@ -112,23 +122,16 @@ const inspectMethod = async (tools, request, summary, engine) => {
     if (body.class_name !== summary.full_name ||
         body.method_name !== request.input.method_name ||
         body.overload_index !== index ||
-        body.overload_count !== candidates.length)
+        body.overload_count !== candidates.length ||
+        body.dex_descriptor !== selected.dex_descriptor)
         throw new AnalysisOutputError(request.operation, "JADX returned a different method or overload inventory");
-    if (body.body.startsWith("// ERROR:"))
-        throw new AnalysisOutputError(request.operation, `JADX did not produce method source: ${body.body}`);
-    if (body.mode === "smali" && candidates.length > 1)
-        throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `JADX ${JADX_RELEASE.version} smali fallback joins all same-name overloads for ${summary.full_name}.${request.input.method_name}; it cannot establish source for only overload ${index}.`);
     return androidResultSchemas.inspect_android_method.parse({
         engine,
         class_name: summary.full_name,
         method: selected,
         overload_count: candidates.length,
         representation: body.mode,
-        body_status: body.body.length === 0 ||
-            body.body ===
-                "// method exists but has no decompiled body (native/abstract)"
-            ? "not_available"
-            : "available",
+        body_status: body.body.length === 0 ? "not_available" : "available",
         fell_back: body.fell_back,
         markers: body.markers,
         source: normalizeJadxText(body.body),
@@ -159,18 +162,29 @@ export const analyzeJadxRequest = async (tools, request, loaded, engine) => {
 const traceReferences = async (tools, request, summary, engine) => {
     const methodName = request.input.method_name;
     const candidates = matchingMethods(summary, request);
-    if (candidates.length > 1)
-        throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `References require a unique method name; ${summary.full_name}.${methodName} has ${candidates.length} overloads. No unambiguous reference result is available.`);
+    if (methodName === undefined && request.input.overload_index !== undefined)
+        inputFailure(request, "overload_index", "Method name is required for an overload index.");
+    if (candidates.length > 1 && request.input.overload_index === undefined)
+        inputFailure(request, "overload_index", `Select one of ${candidates.length} overloads: ${candidates.map((method) => `${method.overload_index}: ${method.reported_signature}`).join("; ")}`);
+    const index = request.input.overload_index ?? 0;
+    const selected = methodName === undefined ? undefined : candidates[index];
+    if (methodName !== undefined && selected === undefined)
+        inputFailure(request, "overload_index", `Index ${index} is outside the ${candidates.length} matching overloads.`);
     const expectedTarget = methodName === undefined
         ? summary.full_name
         : `${summary.full_name}.${methodName}`;
     const xrefs = jadxXrefsSchema.parse(await tools.json(methodName === undefined ? "get_xrefs_to_class" : "get_xrefs_to_method", {
         class_name: summary.full_name,
-        ...(methodName === undefined ? {} : { method_name: methodName }),
+        ...(methodName === undefined
+            ? {}
+            : { method_name: methodName, overload_index: index }),
         limit: 2_147_483_647,
         resolve_line: false,
     }));
     if (xrefs.target !== expectedTarget ||
+        (selected !== undefined &&
+            (xrefs.overload_index !== index ||
+                xrefs.reported_signature !== selected.reported_signature)) ||
         xrefs.total !== xrefs.count ||
         xrefs.count !== xrefs.items.length)
         throw new AnalysisOutputError(request.operation, "JADX references are incomplete or refer to another target");
@@ -178,6 +192,9 @@ const traceReferences = async (tools, request, summary, engine) => {
         engine,
         class_name: summary.full_name,
         method_name: methodName ?? null,
+        overload_index: selected?.overload_index ?? null,
+        reported_signature: selected?.reported_signature ?? null,
+        dex_descriptor: selected?.dex_descriptor ?? null,
         total: xrefs.total,
         references: xrefs.items.map((reference) => ({
             kind: reference.kind,
@@ -187,7 +204,10 @@ const traceReferences = async (tools, request, summary, engine) => {
             top_class: reference.top_class,
             source_line: null,
             dex_offset: null,
+            direct_invokes: reference.direct_invokes ?? null,
+            direct_invokes_exhaustive: reference.direct_invokes_exhaustive ?? null,
         })),
         coverage: "complete",
+        reference_unit: "using_node",
     });
 };