Skip to content

armgit / rea

Public Imported from GitHub
0

Reverse engineer anything with agents, from app behavior down to native binaries.

fix(call-path): keep caller-only unknown coverage from blocking not_found (#2371)

Saim Shafique84cf7791a881
diff --git a/src/domain/callPath.test.ts b/src/domain/callPath.test.ts
index e0f343fca..e78a5f936 100644
--- a/src/domain/callPath.test.ts
+++ b/src/domain/callPath.test.ts
@@ -1,6 +1,7 @@
import { describe, expect, it } from "vitest";
import { buildCallPath } from "./callPath.js";
+import { combineFunctionRelationshipCoverage } from "./functionCallCoverage.js";
import { callPathResultSchema, type CallPathInput } from "./callPathSchemas.js";
import { createEvidence, type Evidence } from "./evidence.js";
import type { JsonValue } from "./jsonValue.js";
@@ -396,6 +397,60 @@ describe("explicit call relationship coverage", () => {
expect(result.limitations).toEqual([reason]);
});
+ it("establishes not_found when only caller coverage is unknown", () => {
+ const reason =
+ "Callers: Upstream xrefs do not establish direct caller relationships.";
+ const result = run([
+ observe("0x1000", ["0x2000"], "rea-workflow", {
+ relationshipCoverage: { status: "unknown", reason },
+ }),
+ observe("0x2000", [], "rea-workflow", {
+ relationshipCoverage: { status: "unknown", reason },
+ }),
+ ]);
+ expect(result).toMatchObject({
+ status: "not_found",
+ search_scope: { exhaustive: true },
+ });
+ expect(result.limitations).toContain(reason);
+ });
+
+ it("stays unknown when callee coverage is unknown", () => {
+ const reason =
+ "Callees: Upstream callees capped results at 500; additional callees remain unknown.";
+ const result = run([
+ observe("0x1000", ["0x2000"], "rea-workflow", {
+ relationshipCoverage: { status: "unknown", reason },
+ }),
+ observe("0x2000", [], "rea-workflow", {
+ relationshipCoverage: { status: "unknown", reason },
+ }),
+ ]);
+ expect(result).toMatchObject({
+ status: "unknown",
+ search_scope: { exhaustive: false },
+ });
+ expect(result.limitations).toContain(reason);
+ });
+
+ it("stays unknown when both caller and callee coverage are unknown", () => {
+ const reason =
+ "Callers: Upstream xrefs do not establish direct caller relationships. Callees: Upstream callees are not observed.";
+ const result = run([
+ observe("0x1000", ["0x2000"], "rea-workflow", {
+ relationshipCoverage: { status: "unknown", reason },
+ }),
+ observe("0x2000", [], "rea-workflow", {
+ relationshipCoverage: { status: "unknown", reason },
+ }),
+ ]);
+ expect(result).toMatchObject({
+ status: "unknown",
+ search_scope: { exhaustive: false },
+ });
+ expect(result.limitations).toContain(reason);
+ });
+
it("ignores incomplete relationship coverage outside the reachable search closure", () => {
const reason = "An unrelated function's callees were not observed.";
const result = run([
@@ -415,6 +470,34 @@ describe("explicit call relationship coverage", () => {
});
});
+describe("IDA-capped callee coverage beside unknown callers", () => {
+ it("keeps the search non-exhaustive for the combined coverage value", () => {
+ const combined = combineFunctionRelationshipCoverage(
+ {
+ status: "unknown",
+ reason: "Upstream xrefs do not establish direct caller relationships.",
+ },
+ {
+ status: "partial",
+ limitations: [
+ "Upstream callees capped results at 500; additional callees remain unknown.",
+ ],
+ },
+ );
+ expect(combined.status).toBe("unknown");
+ const result = run([
+ observe("0x1000", [], "rea-workflow", { relationshipCoverage: combined }),
+ observe("0x4000", []),
+ ]);
+ expect(result).toMatchObject({
+ status: "unknown",
+ search_scope: { exhaustive: false },
+ shortest_hops: null,
+ paths: [],
+ });
+ });
+});
+
describe("call path evidence admission", () => {
it("normalizes hex addresses and rejects duplicates and mixed providers", () => {
expect(
diff --git a/src/domain/callPath.ts b/src/domain/callPath.ts
index 2186c8010..0bd5e88e1 100644
--- a/src/domain/callPath.ts
+++ b/src/domain/callPath.ts
@@ -10,6 +10,7 @@ import {
parseFunctionEvidence,
type FunctionSnapshot,
} from "./functionDossierEvidence.js";
+import { isCallerOnlyUnknownCoverage } from "./functionCallCoverage.js";
import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
/** Minimal directed caller-to-callee adjacency for call-path search. */
@@ -255,10 +256,14 @@ const inspectSearch = ({
// Explicit, Evidence-bound relationship coverage owns completeness;
// generic provider/dossier limitations remain contextual. Legacy Evidence
// without that metadata retains its conservative limitation-based rule.
+ // The search only expands callee edges, so coverage that is unknown
+ // solely because callers are unobservable does not make the searched
+ // callee closure incomplete; the caller caveat stays in limitations.
if (
coverage === null
? snapshot.limitations.length > 0
- : coverage.status !== "complete"
+ : coverage.status !== "complete" &&
+ !isCallerOnlyUnknownCoverage(coverage)
)
incompleteExpandedCoverage = true;
} else if (node === goal) {
diff --git a/src/domain/functionCallCoverage.test.ts b/src/domain/functionCallCoverage.test.ts
new file mode 100644
index 000000000..6fd3fb045
--- /dev/null
+++ b/src/domain/functionCallCoverage.test.ts
@@ -0,0 +1,64 @@
+import { describe, expect, it } from "vitest";
+
+import {
+ combineFunctionRelationshipCoverage,
+ isCallerOnlyUnknownCoverage,
+} from "./functionCallCoverage.js";
+import type { RelationshipCoverage } from "./relationshipCoverage.js";
+
+const unknownCallers: RelationshipCoverage = {
+ status: "unknown",
+ reason: "Upstream xrefs do not establish direct caller relationships.",
+};
+const unknownCallees: RelationshipCoverage = {
+ status: "unknown",
+ reason: "Upstream callees are not observed in this profile.",
+};
+const cappedCallees: RelationshipCoverage = {
+ status: "partial",
+ limitations: [
+ "Upstream callees capped results at 500; additional callees remain unknown.",
+ ],
+};
+const complete: RelationshipCoverage = { status: "complete" };
+
+describe("isCallerOnlyUnknownCoverage", () => {
+ it("detects unknown callers beside complete callees", () => {
+ const combined = combineFunctionRelationshipCoverage(
+ unknownCallers,
+ complete,
+ );
+ expect(combined.status).toBe("unknown");
+ expect(isCallerOnlyUnknownCoverage(combined)).toBe(true);
+ });
+
+ it("rejects unknown callees beside complete callers", () => {
+ const combined = combineFunctionRelationshipCoverage(
+ complete,
+ unknownCallees,
+ );
+ expect(isCallerOnlyUnknownCoverage(combined)).toBe(false);
+ });
+
+ it("rejects unknown coverage on both sides", () => {
+ const combined = combineFunctionRelationshipCoverage(
+ unknownCallers,
+ unknownCallees,
+ );
+ expect(isCallerOnlyUnknownCoverage(combined)).toBe(false);
+ });
+
+ it("rejects unknown callers beside IDA-capped callees", () => {
+ const combined = combineFunctionRelationshipCoverage(
+ unknownCallers,
+ cappedCallees,
+ );
+ expect(combined.status).toBe("unknown");
+ expect(isCallerOnlyUnknownCoverage(combined)).toBe(false);
+ });
+
+ it("rejects complete coverage", () => {
+ const combined = combineFunctionRelationshipCoverage(complete, complete);
+ expect(isCallerOnlyUnknownCoverage(combined)).toBe(false);
+ });
+});
diff --git a/src/domain/functionCallCoverage.ts b/src/domain/functionCallCoverage.ts
index eb2c05a13..b64e78cd6 100644
--- a/src/domain/functionCallCoverage.ts
+++ b/src/domain/functionCallCoverage.ts
@@ -2,6 +2,9 @@ import type { RelationshipCoverage } from "./relationshipCoverage.js";
import type { FunctionDossier } from "./hopperValues.js";
import { uniqueSorted } from "./canonicalOrdering.js";
+const callerCoveragePrefix = "Callers: ";
+const calleeCoveragePrefix = "Callees: ";
+
/** Combine caller and callee read outcomes without losing either explanation. */
export const combineFunctionRelationshipCoverage = (
callers: RelationshipCoverage | undefined,
@@ -20,7 +23,8 @@ export const combineFunctionRelationshipCoverage = (
);
const details = diagnostics.length > 0 ? { diagnostics } : {};
const reasons = reads.flatMap(({ direction, coverage }) => {
- const label = direction === "callers" ? "Callers" : "Callees";
+ const label =
+ direction === "callers" ? callerCoveragePrefix : calleeCoveragePrefix;
const limitations =
coverage === undefined
? ["Provider did not report relationship coverage."]
@@ -29,7 +33,7 @@ export const combineFunctionRelationshipCoverage = (
: coverage.status === "partial"
? coverage.limitations
: [];
- return limitations.map((reason) => `${label}: ${reason}`);
+ return limitations.map((reason) => `${label}${reason}`);
});
if (
reads.some(
@@ -50,6 +54,20 @@ export const combineFunctionRelationshipCoverage = (
return { status: "complete", ...details };
};
+/**
+ * Whether combined relationship coverage is unknown only on the caller side.
+ * The combine helper above prefixes each direction's reasons, so a reason
+ * that carries the caller prefix and no callee prefix records observed
+ * callees with unobservable callers. Forward (callee-edge) searches stay
+ * exhaustive under that caveat; the caller reason remains a limitation.
+ */
+export const isCallerOnlyUnknownCoverage = (
+ coverage: RelationshipCoverage,
+): boolean =>
+ coverage.status === "unknown" &&
+ coverage.reason.startsWith(callerCoveragePrefix) &&
+ !coverage.reason.includes(calleeCoveragePrefix);
+
/** Explain why two resolved call sets cannot establish call-set equality. */
export const functionCallCoverageLimitations = (
coverage: RelationshipCoverage | null,