rea-agents 3.0.0 → 3.2.0

package/dist/domain/javascriptFeatureTrace.js

@@ -5,24 +5,21 @@ import { applicationFeatureTraceResultSchema, } from "./javascriptFeatureTraceSc
 import { findApplicationFeatureSeeds, } from "./javascriptFeatureSeed.js";
 import { traverseApplicationFeature, } from "./javascriptFeatureTraversal.js";
 import { buildJavaScriptNativeHandoffs } from "./javascriptNativeHandoff.js";
-/** Trace a literal feature through a bounded, authority-preserving JAG. */
+/** Trace a literal feature through its complete reachable, authority-preserving JAG. */
 export const traceApplicationFeature = (input) => {
     const allSeedMatches = findApplicationFeatureSeeds(input.graph.nodes, input.seed);
-    const seedMatches = allSeedMatches.slice(0, input.limits.max_seed_matches);
+    const seedMatches = allSeedMatches;
     if (seedMatches.length === 0)
         return noMatchResult(input);
-    const traversal = traverseApplicationFeature(input.graph, seedMatches.map(({ node_id: id }) => id), input.direction, input.limits);
-    const graph = traceGraph(input, seedMatches, traversal, allSeedMatches.length);
-    const allPaths = terminalPaths(traversal, seedMatches);
-    const paths = allPaths.slice(0, input.limits.max_paths);
+    const traversal = traverseApplicationFeature(input.graph, seedMatches.map(({ node_id: id }) => id), input.direction);
+    const graph = traceGraph(input, seedMatches, traversal);
+    const paths = terminalPaths(traversal, seedMatches);
     const nativeHandoffs = buildJavaScriptNativeHandoffs(traversal.nodes, traversal.edges, input.nativeEvidence);
     const evidenceLinks = uniqueSorted([
         input.sourceEvidenceId,
         ...nativeHandoffs.flatMap(({ evidence_ids: ids }) => ids),
     ]);
-    const omissions = traceOmissions(input, traversal, allSeedMatches.length, allPaths.length);
     const semantic = {
-        schema_version: 1,
         source_evidence_id: input.sourceEvidenceId,
         source_graph_id: input.graph.graph_id,
         seed: input.seed,
@@ -40,15 +37,12 @@ export const traceApplicationFeature = (input) => {
             ...factSummary(traversal.nodes, traversal.edges),
         },
         coverage: {
-            status: traceCoverageStatus(input.graph, omissions),
+            status: traceCoverageStatus(input.graph),
             source_graph_status: input.graph.coverage.status,
-            scanned_nodes: input.graph.nodes.length,
             total_seed_matches: allSeedMatches.length,
-            ...omissions,
-            frontier_node_ids: traversal.frontierNodeIds,
         },
         evidence_links: evidenceLinks,
-        limitations: traceLimitations(input.graph, omissions),
+        limitations: traceLimitations(input.graph),
     };
     return applicationFeatureTraceResultSchema.parse({
         ...semantic,
@@ -57,7 +51,6 @@ export const traceApplicationFeature = (input) => {
 };
 const noMatchResult = (input) => {
     const semantic = {
-        schema_version: 1,
         source_evidence_id: input.sourceEvidenceId,
         source_graph_id: input.graph.graph_id,
         seed: input.seed,
@@ -80,13 +73,7 @@ const noMatchResult = (input) => {
         coverage: {
             status: "no-match",
             source_graph_status: input.graph.coverage.status,
-            scanned_nodes: input.graph.nodes.length,
             total_seed_matches: 0,
-            omitted_seed_matches: 0,
-            omitted_nodes: 0,
-            omitted_edges: 0,
-            omitted_paths: 0,
-            frontier_node_ids: [],
         },
         evidence_links: [input.sourceEvidenceId],
         limitations: uniqueSorted([
@@ -99,51 +86,23 @@ const noMatchResult = (input) => {
         trace_id: `jatr_${digestCanonical(semantic)}`,
     });
 };
-const traceGraph = (input, seedMatches, traversal, totalSeedMatches) => {
-    const omitted = traversal.omittedNodeCount +
-        traversal.omittedEdgeCount +
-        (totalSeedMatches - seedMatches.length);
+const traceGraph = (input, seedMatches, traversal) => {
     return createJavaScriptApplicationGraph({
         schema: "JavaScriptApplicationGraph",
-        schema_version: 1,
         root_node_ids: uniqueSorted(seedMatches.map(({ node_id: id }) => id)),
         nodes: traversal.nodes,
         edges: traversal.edges,
-        coverage: traceGraphCoverage(input.graph, input.limits, omitted),
+        coverage: traceGraphCoverage(input.graph),
         limitations: uniqueSorted([
             ...input.graph.limitations,
             "Trace edges retain their source authority; graph connectivity does not prove runtime execution or reachability.",
-            ...(omitted === 0
-                ? []
-                : ["Trace output stopped at explicit caller bounds."]),
         ]),
     });
 };
-const traceGraphCoverage = (source, limits, omitted) => {
-    if (omitted > 0)
-        return {
-            status: "partial",
-            truncated: true,
-            omitted_count: omitted,
-            limits: [
-                {
-                    name: "max-seed-matches",
-                    value: limits.max_seed_matches,
-                    unit: "items",
-                },
-                { name: "max-depth", value: limits.max_depth, unit: "depth" },
-                { name: "max-nodes", value: limits.max_nodes, unit: "items" },
-                { name: "max-edges", value: limits.max_edges, unit: "items" },
-            ],
-        };
+const traceGraphCoverage = (source) => {
     return source.coverage.status === "complete"
         ? { status: "complete", truncated: false, omitted_count: 0, limits: [] }
-        : {
-            status: source.coverage.status,
-            truncated: source.coverage.truncated,
-            omitted_count: source.coverage.omitted_count,
-            limits: source.coverage.limits,
-        };
+        : source.coverage;
 };
 const terminalPaths = (traversal, seeds) => {
     const seedIds = new Set(seeds.map(({ node_id: id }) => id));
@@ -198,25 +157,12 @@ const factSummary = (nodes, edges) => {
         unavailable_facts: states.filter((state) => state === "unavailable").length,
     };
 };
-const traceOmissions = (input, traversal, seedMatches, paths) => ({
-    omitted_seed_matches: Math.max(0, seedMatches - input.limits.max_seed_matches),
-    omitted_nodes: traversal.omittedNodeCount,
-    omitted_edges: traversal.omittedEdgeCount,
-    omitted_paths: Math.max(0, paths - input.limits.max_paths),
-});
-const traceCoverageStatus = (graph, omissions) => Object.values(omissions).some((value) => value > 0)
-    ? "truncated"
-    : graph.coverage.status === "complete"
-        ? "complete-within-source"
-        : "partial";
-const traceLimitations = (graph, omissions) => uniqueSorted([
+const traceCoverageStatus = (graph) => graph.coverage.status === "complete" ? "complete-within-source" : "partial";
+const traceLimitations = (graph) => uniqueSorted([
     "A trace reports graph relationships, not proof that code executed or that a feature is reachable in every state.",
     "Static, native, passive-runtime, inferred, and unknown facts retain their original authority in the returned graph.",
     "Native handoffs never open a binary or invoke a provider automatically; snapshot reuse remains provider/profile/target exact.",
     ...sourceCoverageLimitations(graph),
-    ...(Object.values(omissions).some((value) => value > 0)
-        ? ["Trace results were truncated at explicit caller limits."]
-        : []),
 ]);
 const sourceCoverageLimitations = (graph) => graph.coverage.status === "complete"
     ? []

package/dist/domain/javascriptFeatureTraceSchemas.js

@@ -5,8 +5,8 @@ const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
 const edgeIdSchema = z.string().regex(/^jag_edge_[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(4_096);
-/** Literal starting point for one bounded application trace. */
+const boundedTextSchema = z.string().min(1);
+/** Literal starting point for one application feature trace. */
 const applicationFeatureSeedSchema = z.strictObject({
     kind: z.enum([
         "node-id",
@@ -21,27 +21,13 @@ const applicationFeatureSeedSchema = z.strictObject({
     match: z.enum(["exact", "contains"]).nullable().default(null),
     case_sensitive: z.boolean().default(false),
 });
-const featureTraceLimitsSchema = z.strictObject({
-    max_seed_matches: z.number().int().min(1).max(1_000).default(25),
-    max_depth: z.number().int().min(0).max(64).default(12),
-    max_nodes: z.number().int().min(1).max(50_000).default(2_000),
-    max_edges: z.number().int().min(1).max(100_000).default(4_000),
-    max_paths: z.number().int().min(1).max(1_000).default(100),
-});
-/** Evidence-backed application graph and explicit trace bounds. */
+/** Evidence-backed application graph and feature seed. */
 export const traceApplicationFeatureInputSchema = z
     .strictObject({
     application: evidenceSchema,
-    native_observations: z.array(evidenceSchema).max(64).default([]),
+    native_observations: z.array(evidenceSchema).default([]),
     seed: applicationFeatureSeedSchema,
     direction: z.enum(["outgoing", "incoming", "both"]).default("both"),
-    limits: featureTraceLimitsSchema.default({
-        max_seed_matches: 25,
-        max_depth: 12,
-        max_nodes: 2_000,
-        max_edges: 4_000,
-        max_paths: 100,
-    }),
 })
     .superRefine((input, context) => {
     const ids = input.native_observations.map(({ evidence_id: id }) => id);
@@ -54,51 +40,48 @@ export const traceApplicationFeatureInputSchema = z
 });
 const seedMatchSchema = z.strictObject({
     node_id: nodeIdSchema,
-    kind: z.string().min(1).max(128),
+    kind: z.string().min(1),
     basis: z.enum(["node-id", "label", "identity", "property"]),
-    field: z.string().min(1).max(256),
+    field: z.string().min(1),
 });
 const tracePathSchema = z.strictObject({
     path_id: z.string().regex(/^jatp_[a-f0-9]{64}$/u),
     start_node_id: nodeIdSchema,
     end_node_id: nodeIdSchema,
-    end_kind: z.string().min(1).max(128),
-    node_ids: z.array(nodeIdSchema).min(1).max(65),
-    edge_ids: z.array(edgeIdSchema).max(64),
-    authorities: z.array(z.string().min(1).max(128)).max(16),
+    end_kind: z.string().min(1),
+    node_ids: z.array(nodeIdSchema).min(1),
+    edge_ids: z.array(edgeIdSchema),
+    authorities: z.array(z.string().min(1)),
     contains_inference: z.boolean(),
 });
 const nativeHandoffSchema = z.strictObject({
     native_node_id: nodeIdSchema,
     artifact_sha256: digestSchema,
-    artifact_path: z.string().min(1).max(4_096).nullable(),
-    export_node_ids: z.array(nodeIdSchema).max(1_000),
-    requested_exports: z.array(boundedTextSchema).max(1_000),
+    artifact_path: z.string().min(1).nullable(),
+    export_node_ids: z.array(nodeIdSchema),
+    requested_exports: z.array(boundedTextSchema),
     status: z.enum(["evidence-linked", "requires-provider-analysis"]),
-    providers: z.array(providerSchema).max(64),
-    evidence_ids: z.array(evidenceIdSchema).max(64),
-    recommended_tools: z
-        .array(z.enum([
+    providers: z.array(providerSchema),
+    evidence_ids: z.array(evidenceIdSchema),
+    recommended_tools: z.array(z.enum([
         "open_binary",
         "binary_overview",
         "search_procedures",
         "analyze_function",
         "xrefs",
-    ]))
-        .max(5),
+    ])),
 });
-/** Evidence-preserving bounded subgraph and native-analysis frontiers. */
+/** Evidence-preserving complete reachable subgraph and native-analysis handoffs. */
 export const applicationFeatureTraceResultSchema = z.strictObject({
-    schema_version: z.literal(1),
     trace_id: z.string().regex(/^jatr_[a-f0-9]{64}$/u),
     source_evidence_id: evidenceIdSchema,
     source_graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
     seed: applicationFeatureSeedSchema,
     direction: z.enum(["outgoing", "incoming", "both"]),
-    seed_matches: z.array(seedMatchSchema).max(1_000),
+    seed_matches: z.array(seedMatchSchema),
     graph: javascriptApplicationGraphSchema.nullable(),
-    paths: z.array(tracePathSchema).max(1_000),
-    native_handoffs: z.array(nativeHandoffSchema).max(10_000),
+    paths: z.array(tracePathSchema),
+    native_handoffs: z.array(nativeHandoffSchema),
     summary: z.strictObject({
         matched_seeds: z.number().int().min(0),
         traced_nodes: z.number().int().min(0),
@@ -111,26 +94,15 @@ export const applicationFeatureTraceResultSchema = z.strictObject({
         unavailable_facts: z.number().int().min(0),
     }),
     coverage: z.strictObject({
-        status: z.enum([
-            "complete-within-source",
-            "partial",
-            "truncated",
-            "no-match",
-        ]),
+        status: z.enum(["complete-within-source", "partial", "no-match"]),
         source_graph_status: z.enum([
             "complete",
             "partial",
             "unknown",
             "unavailable",
         ]),
-        scanned_nodes: z.number().int().min(0),
         total_seed_matches: z.number().int().min(0),
-        omitted_seed_matches: z.number().int().min(0),
-        omitted_nodes: z.number().int().min(0),
-        omitted_edges: z.number().int().min(0),
-        omitted_paths: z.number().int().min(0),
-        frontier_node_ids: z.array(nodeIdSchema).max(50_000),
     }),
-    evidence_links: z.array(evidenceIdSchema).min(1).max(65),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    evidence_links: z.array(evidenceIdSchema).min(1),
+    limitations: z.array(boundedTextSchema),
 });

package/dist/domain/javascriptFeatureTraversal.js

@@ -1,56 +1,23 @@
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
 /** Traverse a JAG without treating edge inference as observed reachability. */
-export const traverseApplicationFeature = (graph, seedNodeIds, direction, limits) => {
+export const traverseApplicationFeature = (graph, seedNodeIds, direction) => {
     const nodeById = new Map(graph.nodes.map((node) => [node.node_id, node]));
     const adjacency = buildAdjacency(graph.edges, direction);
     const visited = new Set(seedNodeIds);
     const retainedEdges = new Map();
-    const omittedNodes = new Set();
-    const omittedEdges = new Set();
-    const frontier = new Set();
-    const depths = new Map(seedNodeIds.map((nodeId) => [nodeId, 0]));
     const predecessors = new Map();
     const queue = [...seedNodeIds];
     for (let offset = 0; offset < queue.length; offset += 1) {
         const current = queue[offset];
         if (current === undefined)
             continue;
-        const depth = depths.get(current) ?? 0;
         for (const entry of adjacency.get(current) ?? []) {
-            if (depth >= limits.max_depth) {
-                recordOmission({
-                    entry,
-                    current,
-                    omittedNodes,
-                    omittedEdges,
-                    frontier,
-                });
-                continue;
-            }
-            if (!visited.has(entry.nextNodeId) && visited.size >= limits.max_nodes) {
-                recordOmission({
-                    entry,
-                    current,
-                    omittedNodes,
-                    omittedEdges,
-                    frontier,
-                });
-                continue;
-            }
-            if (!retainedEdges.has(entry.edge.edge_id) &&
-                retainedEdges.size >= limits.max_edges) {
-                omittedEdges.add(entry.edge.edge_id);
-                frontier.add(current);
-                frontier.add(entry.nextNodeId);
-                continue;
-            }
             retainedEdges.set(entry.edge.edge_id, entry.edge);
             if (visited.has(entry.nextNodeId))
                 continue;
             if (!nodeById.has(entry.nextNodeId))
                 continue;
             visited.add(entry.nextNodeId);
-            depths.set(entry.nextNodeId, depth + 1);
             predecessors.set(entry.nextNodeId, {
                 previousNodeId: current,
                 edgeId: entry.edge.edge_id,
@@ -64,11 +31,7 @@ export const traverseApplicationFeature = (graph, seedNodeIds, direction, limits
             .filter((node) => node !== undefined)
             .sort((left, right) => compareCodePoints(left.node_id, right.node_id)),
         edges: [...retainedEdges.values()].sort((left, right) => compareCodePoints(left.edge_id, right.edge_id)),
-        depths,
         predecessors,
-        frontierNodeIds: [...frontier].sort(compareCodePoints),
-        omittedNodeCount: omittedNodes.size,
-        omittedEdgeCount: omittedEdges.size,
     };
 };
 const buildAdjacency = (edges, direction) => {
@@ -92,9 +55,3 @@ const buildAdjacency = (edges, direction) => {
 const addAdjacency = (adjacency, nodeId, entry) => {
     adjacency.set(nodeId, [...(adjacency.get(nodeId) ?? []), entry]);
 };
-const recordOmission = (context) => {
-    context.omittedNodes.add(context.entry.nextNodeId);
-    context.omittedEdges.add(context.entry.edge.edge_id);
-    context.frontier.add(context.current);
-    context.frontier.add(context.entry.nextNodeId);
-};

package/dist/domain/javascriptNativeHandoff.js

@@ -72,7 +72,7 @@ const requestedExports = (nodes) => {
         ...stringArray(observation.properties.requested_members),
         ...stringArray(observation.properties.members),
     ]));
-    return [...new Set(values)].sort(compareCodePoints).slice(0, 1_000);
+    return [...new Set(values)].sort(compareCodePoints);
 };
 const stringArray = (value) => Array.isArray(value)
     ? value.filter((item) => typeof item === "string")