rea-agents 6.0.0 → 6.1.0

package/dist/domain/providerOperationHealth.js

@@ -0,0 +1,54 @@
+/** Caller-visible operational state for one provider bridge. */
+export const PROVIDER_OPERATION_STATES = [
+    "idle",
+    "busy",
+    "exited",
+    "unreachable",
+    "not_started",
+    "unknown",
+];
+/** What the caller should do next for this provider state. */
+export const PROVIDER_RETRY_ACTIONS = [
+    "retry",
+    "wait",
+    "restart_provider",
+    "unknown",
+];
+/** Stage that was in progress when the provider operation failed. */
+export const PROVIDER_FAILURE_STAGES = [
+    "launch",
+    "connection",
+    "analysis",
+    "decompilation",
+    "unknown",
+];
+/**
+ * Choose a recovery action from the observed state.
+ * Startup failures keep their existing install or configuration guidance.
+ */
+export const providerRetryAction = (state, startupFailure = false) => {
+    if (state === "idle")
+        return null;
+    if (startupFailure && state === "exited")
+        return "retry";
+    switch (state) {
+        case "busy":
+            return "wait";
+        case "exited":
+        case "unreachable":
+            return "restart_provider";
+        case "not_started":
+            return "retry";
+        case "unknown":
+            return "unknown";
+    }
+};
+/** Use one stage when every retained request agrees, otherwise unknown. */
+export const sharedProviderFailureStage = (requests) => {
+    const first = requests[0]?.stage;
+    if (first === undefined)
+        return null;
+    return requests.every((request) => request.stage === first)
+        ? first
+        : "unknown";
+};

package/dist/domain/reconstructionVerification.js

@@ -4,6 +4,7 @@ import { z } from "zod";
 import { artifactComparisonResultSchema } from "./artifactComparison.js";
 import { artifactInventoryResultSchema } from "./artifactGraph.js";
 import { uniqueSorted } from "./canonicalOrdering.js";
+import { comparisonSourceEvidenceSides } from "./comparisonSourceEvidence.js";
 import { parseEvidence } from "./evidence.js";
 import { parseEvidenceBundle } from "./evidenceBundle.js";
 import { functionComparisonResultSchema } from "./functionComparison.js";
@@ -12,9 +13,7 @@ import { functionDossierSchema } from "./hopperValues.js";
 import { deriveProcessComparisonStatus, PROCESS_COMPARISON_DIMENSIONS, processCaptureComparisonSchema, parseProcessCapture, } from "./process/processCapture.js";
 import { reconstructionClaimResultSchema, reconstructionSpecificationSchema, reconstructionVerificationResultSchema, } from "./reconstructionVerificationSchemas.js";
 import { reconstructionClaimUnknowns, reconstructionProbes, reconstructionUnknownHeads, } from "./reconstructionUnknowns.js";
-const evidenceIdSchema = prefixedDigestSchema("ev");
 export { reconstructionVerificationInputSchema, reconstructionVerificationResultSchema, } from "./reconstructionVerificationSchemas.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
 const providers = {
     behavioral: {
         operation: "compare_process_captures",
@@ -78,10 +77,8 @@ const evaluateClaim = (claim, records, heads) => {
     if (comparison === undefined)
         throw new TypeError(`Missing comparison Evidence ${claim.comparison_evidence_id}`);
     validateComparisonIdentity(claim, comparison);
-    const sides = sourceSides(claim, comparison);
-    const allSourceIds = [...sides.left, ...sides.right];
-    if (new Set(allSourceIds).size !== allSourceIds.length)
-        throw new TypeError("Comparison source Evidence must be unique and two-sided");
+    const sides = comparisonSourceEvidenceSides(comparison);
+    const allSourceIds = uniqueSorted([...sides.left, ...sides.right]);
     if (!sameSet(comparison.evidence_links, allSourceIds))
         throw new TypeError("Comparison Evidence closure disagrees with its parameters");
     const sources = allSourceIds.map((id) => {
@@ -147,42 +144,6 @@ const validateComparisonIdentity = (claim, evidence) => {
         evidence.subject !== null)
         throw new TypeError("Comparison Evidence identity or authority disagrees");
 };
-const sourceSides = (claim, evidence) => {
-    const parameters = evidence.parameters;
-    let singularSides;
-    if (claim.kind === "behavioral" ||
-        (claim.kind === "structural-function" &&
-            ("left_evidence_id" in parameters || "right_evidence_id" in parameters))) {
-        const parsed = z
-            .object({
-            left_evidence_id: evidenceIdSchema,
-            right_evidence_id: evidenceIdSchema,
-        })
-            .passthrough()
-            .parse(parameters);
-        singularSides = {
-            left: [parsed.left_evidence_id],
-            right: [parsed.right_evidence_id],
-        };
-        if (claim.kind === "behavioral" ||
-            !("left_evidence_ids" in parameters || "right_evidence_ids" in parameters))
-            return singularSides;
-    }
-    const parsed = z
-        .object({
-        left_evidence_ids: z.array(evidenceIdSchema).min(1),
-        right_evidence_ids: z.array(evidenceIdSchema).min(1),
-    })
-        .passthrough()
-        .parse(parameters);
-    if (singularSides !== undefined &&
-        (parsed.left_evidence_ids.length !== 1 ||
-            parsed.right_evidence_ids.length !== 1 ||
-            parsed.left_evidence_ids[0] !== singularSides.left[0] ||
-            parsed.right_evidence_ids[0] !== singularSides.right[0]))
-        throw new TypeError("Function comparison source Evidence aliases disagree");
-    return { left: parsed.left_evidence_ids, right: parsed.right_evidence_ids };
-};
 const observedStatus = (claim, evidence) => {
     if (claim.kind === "behavioral") {
         const result = processCaptureComparisonSchema.parse(evidence.normalized_result);
@@ -215,6 +176,8 @@ const validateProcessStatus = (result) => {
 const authorityLimitations = (claim, sources, sides) => {
     const requiredAuthority = claim.kind === "behavioral" ? "controlled-replay" : "shipped-artifact";
     const limitations = [];
+    if (sides.left.some((id) => sides.right.includes(id)))
+        limitations.push("A source observation appears on both comparison sides; independent original and reconstruction observations are unavailable.");
     if (sources.some((source) => source.authority !== requiredAuthority ||
         (claim.kind === "structural-function"
             ? source.confidence === "inferred"
@@ -250,5 +213,5 @@ const digest = (value) => {
     return createHash("sha256").update(encoded).digest("hex");
 };
 const count = (items, status) => items.filter((item) => item.status === status).length;
-const sameSet = (left, right) => left.length === right.length &&
+const sameSet = (left, right) => uniqueSorted(left).length === uniqueSorted(right).length &&
     uniqueSorted(left).every((id, index) => id === uniqueSorted(right)[index]);

package/dist/domain/reconstructionVerificationSchemas.js

@@ -80,7 +80,7 @@ export const reconstructionClaimResultSchema = z.object({
     comparison_evidence_id: evidenceIdSchema,
     left_evidence_ids: z.array(evidenceIdSchema).min(1),
     right_evidence_ids: z.array(evidenceIdSchema).min(1),
-    evidence_links: z.array(evidenceIdSchema).min(3),
+    evidence_links: z.array(evidenceIdSchema).min(2),
     unknown_ids: z.array(unknownIdSchema),
     limitations: z.array(z.string()),
 });
@@ -106,7 +106,7 @@ export const reconstructionVerificationResultSchema = z
         claim_ids: z.array(claimIdSchema).min(1),
         unknown_ids: z.array(unknownIdSchema),
     })),
-    evidence_links: z.array(evidenceIdSchema).min(3),
+    evidence_links: z.array(evidenceIdSchema).min(2),
     limitations: z.array(z.string()),
 })
     .superRefine((result, context) => {

package/dist/domain/staticRuntimeCorrelation.js

@@ -3,6 +3,7 @@ import canonicalize from "canonicalize";
 import { z } from "zod";
 import { artifactComparisonResultSchema } from "./artifactComparison.js";
 import { uniqueSorted } from "./canonicalOrdering.js";
+import { comparisonSourceEvidenceIds } from "./comparisonSourceEvidence.js";
 import { evidenceSchema, parseEvidence } from "./evidence.js";
 import { functionComparisonResultSchema } from "./functionComparison.js";
 import { PROCESS_PROVIDER, isProcessEvidenceProvider, } from "./process/processEvidenceProvider.js";
@@ -289,52 +290,14 @@ const assertComparisonIdentity = (evidence) => {
                 evidence.provider.version !== "1") ||
         evidence.confidence !== "derived" ||
         evidence.authority !== "analyst-inference" ||
-        evidence.subject !== null ||
-        evidence.evidence_links.length < 2 ||
-        new Set(evidence.evidence_links).size !== evidence.evidence_links.length)
+        evidence.subject !== null)
         throw new TypeError("Comparison Evidence operation, predicate, provider, or citations disagree");
-    const parameterLinks = comparisonParameterLinks(evidence);
-    if (!sameSet(parameterLinks, evidence.evidence_links))
+    const expectedLinks = comparisonSourceEvidenceIds(evidence);
+    const actualLinks = uniqueSorted(evidence.evidence_links);
+    if (expectedLinks.length !== actualLinks.length ||
+        expectedLinks.some((id, index) => id !== actualLinks[index]))
         throw new TypeError("Comparison Evidence closure disagrees with its source parameters");
 };
-const comparisonParameterLinks = (evidence) => {
-    if (evidence.operation === "compare_process_captures") {
-        const parameters = z
-            .object({
-            left_evidence_id: evidenceIdSchema,
-            right_evidence_id: evidenceIdSchema,
-        })
-            .passthrough()
-            .parse(evidence.parameters);
-        return [parameters.left_evidence_id, parameters.right_evidence_id];
-    }
-    const parameters = z
-        .object({
-        left_evidence_id: evidenceIdSchema.optional(),
-        right_evidence_id: evidenceIdSchema.optional(),
-        left_evidence_ids: z.array(evidenceIdSchema).min(1).optional(),
-        right_evidence_ids: z.array(evidenceIdSchema).min(1).optional(),
-    })
-        .passthrough()
-        .parse(evidence.parameters);
-    const left = parameters.left_evidence_id === undefined
-        ? (parameters.left_evidence_ids ?? [])
-        : [parameters.left_evidence_id];
-    const right = parameters.right_evidence_id === undefined
-        ? (parameters.right_evidence_ids ?? [])
-        : [parameters.right_evidence_id];
-    if (left.length === 0 || right.length === 0)
-        throw new TypeError("Comparison Evidence omitted its source parameters");
-    return [...left, ...right];
-};
-const sameSet = (left, right) => {
-    if (left.length !== right.length)
-        return false;
-    const rightSet = new Set(right);
-    return (rightSet.size === right.length &&
-        new Set(left).size === left.length &&
-        left.every((item) => rightSet.has(item)));
-};
 const observedPattern = (staticStatus, runtimeStatus) => {
     if (staticStatus === "truncated" || runtimeStatus === "truncated")
         return "truncated";

package/dist/domain/webBundleAnalysis.js

@@ -88,24 +88,36 @@ export const webSourceMapsSchema = z
     requested: z.number().int().min(0),
     processed: z.number().int().min(0),
     items: z.array(sourceMapSchema),
+    limitation: z.string().min(1).optional(),
 })
     .superRefine((sourceMaps, context) => {
-    if (sourceMaps.requested !== sourceMaps.processed ||
+    if (sourceMaps.processed > sourceMaps.requested ||
         sourceMaps.processed !== sourceMaps.items.length)
         context.addIssue({
             code: "custom",
             message: "Source-map coverage counts are inconsistent",
         });
+    if (sourceMaps.processed < sourceMaps.requested &&
+        sourceMaps.limitation === undefined)
+        context.addIssue({
+            code: "custom",
+            message: "Unprocessed source maps require an explicit coverage limitation",
+            path: ["limitation"],
+        });
     const statuses = sourceMaps.items.map(({ status }) => status);
     const retained = statuses.filter((status) => status === "included" || status === "partial").length;
-    const allowedStatuses = sourceMaps.items.length === 0
-        ? ["not_requested", "unavailable"]
-        : retained === 0
+    const allowedStatuses = sourceMaps.processed < sourceMaps.requested
+        ? retained === 0
             ? ["unavailable"]
-            : retained === sourceMaps.items.length &&
-                !statuses.includes("partial")
-                ? ["included"]
-                : ["partial"];
+            : ["partial"]
+        : sourceMaps.items.length === 0
+            ? ["not_requested", "unavailable"]
+            : retained === 0
+                ? ["unavailable"]
+                : retained === sourceMaps.items.length &&
+                    !statuses.includes("partial")
+                    ? ["included"]
+                    : ["partial"];
     if (!allowedStatuses.includes(sourceMaps.status))
         context.addIssue({
             code: "custom",

package/dist/domain/webBundleAnalyzerInspection.js

@@ -2,6 +2,7 @@ import { parse } from "@babel/parser";
 import * as t from "@babel/types";
 import { sanitizeEndpointCandidate } from "./browserObservation.js";
 import { traverseJavaScriptAst } from "./javascript/javascriptSemanticTraversal.js";
+import { classifyParsedJavaScriptOpenReceivers } from "./javascript/javascriptSemanticAnalysis.js";
 import { semanticStaticPropertyName } from "./javascript/javascriptAstValues.js";
 import { calleeName, endpointArgument, stringValue, } from "./javascript/javascriptStaticAnalysisHelpers.js";
 import { location, locationFields, objectString, objectValue, resolveSpecifier, isUrlLikeModuleSpecifier, } from "./webBundleAnalyzerAst.js";
@@ -22,14 +23,15 @@ export const analyzeScript = (script, accumulator) => {
     }
     accumulator.parsedScripts += 1;
     detectVendorFingerprints(script, accumulator);
+    const openReceiverFacts = classifyParsedJavaScriptOpenReceivers(file);
     traverseJavaScriptAst(file, {
         enter: (node) => {
             accumulator.visitedNodes += 1;
-            inspectNode(script, node, accumulator);
+            inspectNode(script, node, accumulator, openReceiverFacts);
         },
     });
 };
-const inspectNode = (script, node, accumulator) => {
+const inspectNode = (script, node, accumulator, openReceiverFacts) => {
     if ((t.isImportDeclaration(node) || t.isExportAllDeclaration(node)) &&
         node.source !== undefined)
         addEdge({
@@ -57,10 +59,12 @@ const inspectNode = (script, node, accumulator) => {
         });
     if (t.isObjectProperty(node))
         inspectRouteProperty(script, node, accumulator);
-    if (t.isCallExpression(node) || t.isNewExpression(node))
-        inspectCall(script, node, accumulator);
+    if (t.isCallExpression(node) ||
+        t.isOptionalCallExpression(node) ||
+        t.isNewExpression(node))
+        inspectCall(script, node, accumulator, openReceiverFacts);
 };
-const inspectCall = (script, node, accumulator) => {
+const inspectCall = (script, node, accumulator, openReceiverFacts) => {
     const name = calleeName(node.callee);
     const first = stringValue(node.arguments[0]);
     if ((name === "require" || name.endsWith(".require")) && first !== undefined)
@@ -95,7 +99,7 @@ const inspectCall = (script, node, accumulator) => {
             accumulator,
         });
     }
-    const endpoint = endpointArgument(name, node.arguments, node.callee);
+    const endpoint = endpointArgument(name, node.arguments, node.callee, openReceiverFacts.get(node.start ?? -1));
     if (endpoint !== undefined)
         addFinding({
             collection: accumulator.endpoints,
@@ -105,8 +109,9 @@ const inspectCall = (script, node, accumulator) => {
             node,
             accumulator,
         });
-    if (name.endsWith("modelContext.registerTool") ||
-        name === "modelContext.registerTool")
+    if ((t.isCallExpression(node) || t.isNewExpression(node)) &&
+        (name.endsWith("modelContext.registerTool") ||
+            name === "modelContext.registerTool"))
         addWebMcpDeclaration(script, node, accumulator);
 };
 const inspectRouteProperty = (script, node, accumulator) => {

package/dist/domain/webBundleAnalyzerResult.js

@@ -3,10 +3,16 @@ export const buildWebBundleAnalysis = (inspection, sourceScripts, sourceMaps, ac
     const unavailable = inspection.scripts.items
         .filter((script) => !script.source.included)
         .map(({ script_key }) => script_key);
+    const omittedScripts = captureBudgetOmission(inspection, "scripts");
+    const omittedSourceMaps = sourceMaps.status === "not_requested"
+        ? undefined
+        : captureBudgetOmission(inspection, "source_maps");
     const sourceMapIncomplete = sourceMaps.status === "partial" || sourceMaps.status === "unavailable";
     const partial = accumulator.parseFailures > 0 ||
         unavailable.length > 0 ||
-        sourceMapIncomplete;
+        sourceMapIncomplete ||
+        omittedScripts !== undefined ||
+        omittedSourceMaps !== undefined;
     return webBundleAnalysisSchema.parse({
         capture: buildCaptureObservation(inspection, sourceScripts),
         observations: {
@@ -25,6 +31,8 @@ export const buildWebBundleAnalysis = (inspection, sourceScripts, sourceMaps, ac
             unavailable,
             parseFailures: accumulator.parseFailures,
             sourceMaps,
+            omittedScripts,
+            omittedSourceMaps,
         }),
         completeness: buildCompleteness({
             partial,
@@ -58,6 +66,15 @@ const chunkNode = (script) => {
     };
 };
 const buildUnknowns = (input) => [
+    ...(input.omittedScripts === undefined
+        ? []
+        : [
+            {
+                dimension: "script_inventory",
+                reason: captureBudgetReason("script records", input.omittedScripts),
+                affected_script_keys: [],
+            },
+        ]),
     ...(input.unavailable.length === 0
         ? []
         : [
@@ -76,13 +93,23 @@ const buildUnknowns = (input) => [
                 affected_script_keys: input.sourceScripts.map(({ script_key }) => script_key),
             },
         ]),
+    ...(input.omittedSourceMaps === undefined
+        ? []
+        : [
+            {
+                dimension: "source_maps",
+                reason: captureBudgetReason("source-map declarations", input.omittedSourceMaps),
+                affected_script_keys: [],
+            },
+        ]),
     ...(input.sourceMaps.status === "not_requested" ||
         input.sourceMaps.status === "included"
         ? []
         : [
             {
                 dimension: "source_maps",
-                reason: "One or more requested source maps were unavailable or incomplete",
+                reason: input.sourceMaps.limitation ??
+                    "One or more requested source maps were unavailable or incomplete",
                 affected_script_keys: input.sourceMaps.items
                     .filter(({ status }) => status !== "included")
                     .map(({ script_key }) => script_key)
@@ -90,6 +117,18 @@ const buildUnknowns = (input) => [
             },
         ]),
 ];
+const captureBudgetOmission = (inspection, section) => {
+    const exclusions = inspection.completeness.excluded.filter((exclusion) => exclusion.section === section &&
+        exclusion.reason === "resource_budget_exhausted");
+    if (exclusions.length === 0)
+        return undefined;
+    if (exclusions.some(({ count }) => count === null))
+        return null;
+    return exclusions.reduce((sum, { count }) => sum + (count ?? 0), 0);
+};
+const captureBudgetReason = (label, count) => count === null
+    ? `Capture omitted an unknown number of ${label} because its resource budget was exhausted.`
+    : `Capture omitted ${String(count)} ${label} because its resource budget was exhausted.`;
 const buildCompleteness = (input) => ({
     status: input.partial ? "partial" : "complete",
     parsed_scripts: input.parsedScripts,

package/dist/domain/webRuntime.js

@@ -2,6 +2,20 @@ import { z } from "zod";
 import { browserAllowedOriginsSchema, browserEndpointSchema, } from "./browserObservation.js";
 import { browserVersionSchema } from "./browserObservationSchemas.js";
 import { jsonObjectSchema } from "./jsonValue.js";
+// CDP positions are zero-based and relative to the resource named by url.
+// With a script ID that is the script's enclosing resource: the script file,
+// or the HTML document for an inline script. An empty script ID marks a
+// position a request initiator reported, such as parser markup or a module
+// import in a script file; it still locates url, but has no session-script
+// association to join captured source or resource_start.
+// trace_web_source_location takes one-based, script-relative lines, so the
+// advertised units keep callers from passing a position off by one or by an
+// inline script's offset.
+const SCRIPT_ID = "CDP session script ID; empty for a position a request initiator reported, which has no session-script association for joining captured source or resource_start.";
+const RESOURCE_LINE = "Zero-based line in the resource named by url, as reported by CDP: the script file for an external script (including a module-import initiator), or the HTML document for an inline script or parser markup.";
+const RESOURCE_COLUMN = "Zero-based UTF-16 column on that line of the resource named by url, as reported by CDP.";
+const START_LINE = "Zero-based line where the script text starts in its enclosing resource (the HTML document for an inline script).";
+const START_COLUMN = "Zero-based UTF-16 column where the script text starts on that line of its enclosing resource.";
 /** Scope for one externally owned page; omitted origins select its current origin. */
 export const webRuntimeScopeSchema = z.strictObject({
     cdp_endpoint: browserEndpointSchema,
@@ -22,8 +36,8 @@ export const webRuntimeSourceSchema = z.object({
     language: z.string().nullable(),
     resource_start: z
         .object({
-        line_number: z.number().int().min(0),
-        column_number: z.number().int().min(0),
+        line_number: z.number().int().min(0).describe(START_LINE),
+        column_number: z.number().int().min(0).describe(START_COLUMN),
     })
         .nullable(),
     source: z.discriminatedUnion("state", [
@@ -42,10 +56,10 @@ export const webRuntimeSourceSchema = z.object({
 });
 /** Producer callsite coordinates are zero-based resource lines and UTF-16 columns. */
 export const webRuntimeLocationSchema = z.object({
-    script_id: z.string(),
+    script_id: z.string().describe(SCRIPT_ID),
     url: z.string().nullable(),
-    line_number: z.number().int().min(0),
-    column_number: z.number().int().min(0).nullable(),
+    line_number: z.number().int().min(0).describe(RESOURCE_LINE),
+    column_number: z.number().int().min(0).nullable().describe(RESOURCE_COLUMN),
     function_name: z.string().nullable(),
     source_association: z.enum(["script_id", "unknown"]),
 });

package/dist/domain/webSourceLocation.js

@@ -85,6 +85,7 @@ export const WEB_SOURCE_MAP_LIMITS = {
     outputBytes: 32 * 1024 * 1024,
     decodedRows: 262144,
     decodedSegments: 262144,
+    decodedRecords: 262144,
     sectionDepth: 64,
     decodeTimeoutMs: 20000,
 };

package/dist/firmware/FirmwareFiles.js

@@ -102,7 +102,7 @@ export const readFirmwareReport = async (path, operation) => {
         if (bytes === undefined)
             throw new AnalysisOutputError(operation, `Report exceeded ${FIRMWARE_LIMITS.reportBytes} bytes`);
         try {
-            const value = JSON.parse(bytes.toString("utf8"));
+            const value = JSON.parse(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes));
             return value;
         }
         catch (cause) {

package/dist/generatedPackageMetadata.js

@@ -1,7 +1,7 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "6.0.0", // x-release-please-version
+    version: "6.1.0", // x-release-please-version
     serverSdkVersion: "2.3.1",
     clientSdkVersion: "2.3.1",
     coreSdkVersion: "2.3.1",

package/dist/ghidra/GhidraAnalysisProfile.js

@@ -27,6 +27,11 @@ export const resolveGhidraAnalysisProfile = (target, identity, installation, sig
             annotation_policy: "atomic-function-entry-metadata-v1",
             load_image_observations: "source-mappings-entry-context-v2",
             function_body_evidence: "complete-inclusive-ranges-v1",
+            function_references: "complete-body-and-entry-reference-manager-v2",
+            location_resolution: "explicit-address-exact-name-first-v2",
+            process_launch: installation.platform === "win32"
+                ? "official-headless-script-v1"
+                : "inspected-jvm-launch-support-v1",
             ...(dos
                 ? {
                     load_image_evidence: dosCom