rea-agents 3.0.0 → 3.1.0

package/dist/domain/browserCaptureComparison.js

@@ -1,75 +1,27 @@
 import { z } from "zod";
 import { browserScenarioDiffSchema, compareBrowserScenarios, compareBrowserScenariosInputSchema, } from "./browserScenarioDiff.js";
 import { compareWebCaptures, captureSnapshotSchema, webCaptureDiffSchema, } from "./webCaptureDiff.js";
-/** Top-level MCP shape for legacy page or step-indexed scenario comparison. */
-export const browserCaptureComparisonWireSchema = z
-    .strictObject({
-    before: captureSnapshotSchema
-        .optional()
-        .describe("Earlier passive web-page capture; pair with after."),
-    after: captureSnapshotSchema
-        .optional()
-        .describe("Later passive web-page capture; pair with before."),
-    before_scenario: compareBrowserScenariosInputSchema.shape.before_scenario
-        .optional()
-        .describe("Earlier browser scenario capture; pair with after_scenario."),
-    after_scenario: compareBrowserScenariosInputSchema.shape.after_scenario
-        .optional()
-        .describe("Later browser scenario capture; pair with before_scenario."),
-    normalization: compareBrowserScenariosInputSchema.shape.normalization.describe("Scenario-only exact-literal normalization policy."),
-    max_changes: z
-        .number()
-        .int()
-        .min(1)
-        .max(20_000)
-        .default(2_000)
-        .describe("Maximum normalized change records to retain."),
-})
-    .superRefine((input, context) => {
-    const hasPassive = input.before !== undefined || input.after !== undefined;
-    const hasScenario = input.before_scenario !== undefined || input.after_scenario !== undefined;
-    if (hasPassive === hasScenario)
-        context.addIssue({
-            code: "custom",
-            message: "Provide exactly one complete pair: before/after or before_scenario/after_scenario",
-        });
-    if (hasPassive && (input.before === undefined || input.after === undefined))
-        context.addIssue({
-            code: "custom",
-            message: "Passive comparison requires both before and after",
-        });
-    if (hasScenario &&
-        (input.before_scenario === undefined ||
-            input.after_scenario === undefined))
-        context.addIssue({
-            code: "custom",
-            message: "Browser scenario comparison requires both before_scenario and after_scenario",
-        });
-    if (hasPassive && input.normalization.rules.length > 0)
-        context.addIssue({
-            code: "custom",
-            path: ["normalization"],
-            message: "Literal normalization rules apply only to browser scenario captures",
-        });
-});
-/** Parsed legacy page snapshots or step-indexed browser scenarios. */
-export const browserCaptureComparisonInputSchema = browserCaptureComparisonWireSchema.transform((input) => {
-    if (input.before_scenario !== undefined &&
-        input.after_scenario !== undefined)
-        return {
-            before_scenario: input.before_scenario,
-            after_scenario: input.after_scenario,
-            normalization: input.normalization,
-            max_changes: input.max_changes,
-        };
-    if (input.before !== undefined && input.after !== undefined)
-        return {
-            before: input.before,
-            after: input.after,
-            max_changes: input.max_changes,
-        };
-    throw new TypeError("Capture comparison pair refinement failed");
-});
+const maxChangesSchema = z
+    .number()
+    .int()
+    .min(1)
+    .max(20_000)
+    .default(2_000)
+    .describe("Maximum normalized change records to retain.");
+/** Top-level MCP shape for exactly one complete passive or scenario pair. */
+export const browserCaptureComparisonInputSchema = z.union([
+    z.strictObject({
+        before: captureSnapshotSchema.describe("Earlier passive web-page capture."),
+        after: captureSnapshotSchema.describe("Later passive web-page capture."),
+        max_changes: maxChangesSchema,
+    }),
+    z.strictObject({
+        before_scenario: compareBrowserScenariosInputSchema.shape.before_scenario.describe("Earlier browser scenario capture."),
+        after_scenario: compareBrowserScenariosInputSchema.shape.after_scenario.describe("Later browser scenario capture."),
+        normalization: compareBrowserScenariosInputSchema.shape.normalization.describe("Exact-literal normalization policy."),
+        max_changes: maxChangesSchema,
+    }),
+]);
 /** Result from passive page or browser scenario comparison. */
 export const browserCaptureComparisonSchema = z.union([
     browserScenarioDiffSchema,

package/dist/domain/browserObservation.js

@@ -186,9 +186,7 @@ const DEFAULT_BROWSER_INSPECTION_LIMITS = {
     max_websocket_shape_bytes: 64 * 1_024,
     max_total_websocket_shape_bytes: 1_024 * 1_024,
 };
-/** Public input for one passive, bounded inspection of an existing page. */
-export const inspectWebPageInputSchema = z
-    .object({
+const inspectWebPageInputFacts = {
     ...approvedBrowserInput,
     target_id: z.string().trim().min(1).max(256),
     observation_ms: z.number().int().min(0).max(10_000).default(500),
@@ -199,12 +197,21 @@ export const inspectWebPageInputSchema = z
     json_body_schema_approved: z.boolean().default(false),
     include_websocket_shapes: z.boolean().default(false),
     websocket_shape_approved: z.boolean().default(false),
-    include_script_sources: z.boolean().default(false),
     include_storage_keys: z.boolean().default(false),
     include_storage_fingerprints: z.boolean().default(false),
     limits: browserInspectionLimitsSchema.default(DEFAULT_BROWSER_INSPECTION_LIMITS),
-})
-    .superRefine((input, context) => {
+};
+const inspectWebPageWithoutSourceSchema = z.strictObject({
+    ...inspectWebPageInputFacts,
+    include_script_sources: z.literal(false).default(false),
+    source_capture_approved: z.literal(false).default(false),
+});
+const inspectWebPageWithSourceShapeSchema = z.strictObject({
+    ...inspectWebPageInputFacts,
+    include_script_sources: z.literal(true).default(true),
+    source_capture_approved: z.literal(true),
+});
+const refineInspectWebPageInput = (input, context) => {
     if (input.include_storage_fingerprints && !input.include_storage_keys)
         context.addIssue({
             code: "custom",
@@ -260,14 +267,20 @@ export const inspectWebPageInputSchema = z
             path: ["limits", "max_websocket_shape_bytes"],
             message: "Per-frame WebSocket limit cannot exceed the total frame limit",
         });
-    if (input.limits.max_ax_text_field_bytes >
-        input.limits.max_total_ax_text_bytes)
+    if (input.limits.max_ax_text_field_bytes > input.limits.max_total_ax_text_bytes)
         context.addIssue({
             code: "custom",
             path: ["limits", "max_ax_text_field_bytes"],
             message: "Per-field accessibility text limit cannot exceed the total text limit",
         });
-});
+};
+/** Source-capturing inspection input, reusable by static bundle analysis. */
+export const inspectWebPageWithSourceInputSchema = inspectWebPageWithSourceShapeSchema.superRefine(refineInspectWebPageInput);
+/** Public input for one passive, bounded inspection of an existing page. */
+export const inspectWebPageInputSchema = z.union([
+    inspectWebPageWithoutSourceSchema.superRefine(refineInspectWebPageInput),
+    inspectWebPageWithSourceInputSchema,
+]);
 export const sanitizedBrowserUrlSchema = z.object({
     url: z.string().max(MAX_SANITIZED_BROWSER_URL_CHARS),
     origin: z.string().max(2_048).nullable(),

package/dist/domain/bytecodeProvider.js

@@ -109,48 +109,46 @@ export function detectArtifactFormat(path) {
         return "zipapp";
     return null;
 }
+const STANDARD_LIBRARY_PATH_MARKERS = [
+    "/stdlib/",
+    "/site-packages/",
+    "java/",
+    "javax/",
+    "sun/",
+];
+const STANDARD_LIBRARY_SYMBOL_MARKERS = ["java.", "javax.", "sun.", "__"];
+const GENERATED_PATH_MARKERS = [
+    "/generated/",
+    "_generated",
+    "/build/",
+    "/target/",
+    "/dist-packages/",
+    "/__pycache__/",
+];
+const GENERATED_SYMBOL_MARKERS = ["Generated", "_generated"];
+const VENDORED_PATH_MARKERS = [
+    "/vendor/",
+    "/vendored/",
+    "/third_party/",
+    "/3rdparty/",
+    "/node_modules/",
+];
+const BUNDLED_PATH_MARKERS = ["/bundle/", "/bundled/", ".jar!", ".war!"];
+const includesAny = (value, markers) => markers.some((marker) => value.includes(marker));
+const startsWithAny = (value, markers) => markers.some((marker) => value.startsWith(marker));
 /** Classify bytecode symbol provenance. */
 export function classifyProvenance(path, symbolName) {
     const lower = path.toLowerCase();
-    // Standard library paths
-    if (lower.includes("/stdlib/") ||
-        lower.includes("/site-packages/") ||
-        lower.includes("java/") ||
-        lower.includes("javax/") ||
-        lower.includes("sun/") ||
-        symbolName.startsWith("java.") ||
-        symbolName.startsWith("javax.") ||
-        symbolName.startsWith("sun.") ||
-        symbolName.startsWith("__")) {
+    if (includesAny(lower, STANDARD_LIBRARY_PATH_MARKERS) ||
+        startsWithAny(symbolName, STANDARD_LIBRARY_SYMBOL_MARKERS))
         return "standard_library";
-    }
-    // Generated code
-    if (lower.includes("/generated/") ||
-        lower.includes("_generated") ||
-        lower.includes("/build/") ||
-        lower.includes("/target/") ||
-        lower.includes("/dist-packages/") ||
-        lower.includes("/__pycache__/") ||
-        symbolName.includes("Generated") ||
-        symbolName.includes("_generated")) {
+    if (includesAny(lower, GENERATED_PATH_MARKERS) ||
+        includesAny(symbolName, GENERATED_SYMBOL_MARKERS))
         return "generated";
-    }
-    // Vendored code
-    if (lower.includes("/vendor/") ||
-        lower.includes("/vendored/") ||
-        lower.includes("/third_party/") ||
-        lower.includes("/3rdparty/") ||
-        lower.includes("/node_modules/") ||
-        lower.includes("/vendor/")) {
+    if (includesAny(lower, VENDORED_PATH_MARKERS))
         return "vendored";
-    }
-    // Bundled code
-    if (lower.includes("/bundle/") ||
-        lower.includes("/bundled/") ||
-        lower.includes(".jar!") ||
-        lower.includes(".war!")) {
+    if (includesAny(lower, BUNDLED_PATH_MARKERS))
         return "bundled";
-    }
     return "application";
 }
 /** Analyze a set of bytecode artifacts and produce a summary. */

package/dist/domain/callPath.js

@@ -178,9 +178,10 @@ const parseSnapshots = (groups) => {
     return snapshots;
 };
 const assertCompatible = (snapshots) => {
-    const first = snapshots.values().next().value;
-    if (first === undefined)
+    const firstEntry = snapshots.values().next();
+    if (firstEntry.done)
         return;
+    const first = firstEntry.value;
     for (const snapshot of snapshots.values()) {
         if (snapshot.subject.digest.sha256 !== first.subject.digest.sha256 ||
             snapshot.subject.format !== first.subject.format ||

package/dist/domain/conformanceReplay.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { conformancePackageSchema, } from "./conformancePackage.js";
-import { trustGateResultSchema } from "./conformanceTrustGate.js";
+import { evaluatePackageTrustGates, trustGateResultSchema, } from "./conformanceTrustGate.js";
 /** Result of a single scenario replay. */
 export const scenarioReplayResultSchema = z.strictObject({
     scenario_id: z.string().min(1),
@@ -25,6 +25,7 @@ export const packageReplayResultSchema = z.strictObject({
         .strictObject({
         scenario_id: z.string().min(1),
         dimension: z.string().min(1),
+        evidence_id: z.string().min(1),
         message: z.string(),
     })
         .nullable(),
@@ -84,6 +85,7 @@ export async function replayConformancePackage(packageInput, actualEvidence, run
         ? {
             scenario_id: first_drift_gate.scenario_id,
             dimension: first_drift_gate.first_divergence.dimension,
+            evidence_id: first_drift_gate.first_divergence.evidence_id,
             message: first_drift_gate.first_divergence.message,
         }
         : null;
@@ -100,5 +102,3 @@ export async function replayConformancePackage(packageInput, actualEvidence, run
         first_drift,
     };
 }
-/** Import trust gate evaluator for replay. */
-import { evaluatePackageTrustGates } from "./conformanceTrustGate.js";

package/dist/domain/conformanceTrustGate.js

@@ -35,11 +35,130 @@ const SEMANTIC_DIMENSIONS = new Set([
     "stdout",
     "stderr",
     "filesystem",
+    "process",
     "process_tree",
     "shim_events",
     "protocol_events",
     "event_journal",
 ]);
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const uniqueStrings = (values) => [
+    ...new Set(values.filter((value) => value.length > 0)),
+];
+const stringValues = (value) => {
+    if (typeof value === "string")
+        return value.length > 0 ? [value] : [];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string" && item.length > 0);
+};
+const evidenceIds = (record) => uniqueStrings([
+    ...stringValues(record["evidence_id"]),
+    ...stringValues(record["evidence_ids"]),
+    ...stringValues(record["evidence_links"]),
+]);
+const incompleteStatus = (value) => {
+    if (!isRecord(value))
+        return null;
+    const record = value;
+    if (record["truncated"] === true)
+        return "truncated";
+    const status = record["status"];
+    if (status === "truncated")
+        return "truncated";
+    if (status === "unknown" ||
+        status === "unavailable" ||
+        status === "partial" ||
+        status === "incomplete" ||
+        status === "unverifiable" ||
+        status === "failed" ||
+        status === "not_approved")
+        return "unknown";
+    for (const key of ["coverage", "completeness"]) {
+        const nested = record[key];
+        if (!isRecord(nested))
+            continue;
+        const nestedStatus = incompleteStatus(nested);
+        if (nestedStatus !== null)
+            return nestedStatus;
+    }
+    return null;
+};
+const hasResidualUnknowns = (value) => isRecord(value) &&
+    Array.isArray(value["residual_unknowns"]) &&
+    value["residual_unknowns"].length > 0;
+const unknownScopes = (record) => {
+    const residualUnknowns = record["residual_unknowns"];
+    if (!Array.isArray(residualUnknowns))
+        return [];
+    return residualUnknowns.flatMap((item) => {
+        if (!isRecord(item) || typeof item["scope"] !== "string")
+            return [];
+        return [item["scope"]];
+    });
+};
+const evidenceView = (input) => {
+    if (!isRecord(input))
+        return {
+            values: {},
+            evidence_ids: [],
+            status: null,
+            unknown_scopes: [],
+        };
+    const normalized = input["normalized_result"];
+    const values = isRecord(normalized) ? normalized : input;
+    const normalizedStatus = isRecord(normalized)
+        ? incompleteStatus(normalized)
+        : null;
+    return {
+        values,
+        evidence_ids: evidenceIds(input),
+        status: incompleteStatus(input) ?? normalizedStatus,
+        unknown_scopes: uniqueStrings([
+            ...unknownScopes(input),
+            ...(isRecord(normalized) ? unknownScopes(normalized) : []),
+        ]),
+    };
+};
+const dimensionScope = (dimensionName) => {
+    if (dimensionName === "exit_code" || dimensionName === "exit")
+        return "exit";
+    if (dimensionName === "process" ||
+        dimensionName === "process_tree" ||
+        dimensionName === "event_journal")
+        return "process";
+    if (dimensionName === "stdout" || dimensionName === "stderr")
+        return "terminal";
+    if (dimensionName === "filesystem")
+        return "filesystem";
+    if (dimensionName === "shim_events")
+        return "shim";
+    if (dimensionName === "protocol_events")
+        return "protocol";
+    return null;
+};
+const statusForDimension = (view, dimensionName) => {
+    const valueStatus = incompleteStatus(view.values[dimensionName]);
+    if (valueStatus !== null)
+        return valueStatus;
+    if (hasResidualUnknowns(view.values[dimensionName]))
+        return "unknown";
+    const scope = dimensionScope(dimensionName);
+    return scope !== null && view.unknown_scopes.includes(scope)
+        ? "unknown"
+        : view.status;
+};
+const comparisonIncompleteStatus = (expected, actual, options) => {
+    const expectedStatus = options.expected_status ?? incompleteStatus(expected);
+    const actualStatus = options.actual_status ?? incompleteStatus(actual);
+    if (options.truncated)
+        return "truncated";
+    if (expectedStatus === "truncated" || actualStatus === "truncated")
+        return "truncated";
+    if (expectedStatus === "unknown" || actualStatus === "unknown")
+        return "unknown";
+    return null;
+};
 /** Check if a dimension name is volatile (timing/normalization noise). */
 export function isVolatileDimension(name) {
     return VOLATILE_DIMENSIONS.has(name);
@@ -63,15 +182,19 @@ export function compareDimension(dimensionName, expected, actual, options = {})
             name: dimensionName,
             status: "match",
             message: "volatile dimension ignored",
-            evidence_ids: [],
+            evidence_ids: uniqueStrings(options.evidence_ids ?? []),
         };
     }
-    if (options.truncated) {
+    const status = comparisonIncompleteStatus(expected, actual, options);
+    const resultEvidenceIds = uniqueStrings(options.evidence_ids ?? []);
+    if (status !== null) {
         return {
             name: dimensionName,
-            status: "truncated",
-            message: "evidence was truncated",
-            evidence_ids: [],
+            status,
+            message: status === "truncated"
+                ? "evidence was truncated"
+                : "evidence completeness is unknown",
+            evidence_ids: resultEvidenceIds,
         };
     }
     if (expected === undefined && actual === undefined) {
@@ -79,15 +202,15 @@ export function compareDimension(dimensionName, expected, actual, options = {})
             name: dimensionName,
             status: "unknown",
             message: "both expected and actual are undefined",
-            evidence_ids: [],
+            evidence_ids: resultEvidenceIds,
         };
     }
     if (expected === undefined || actual === undefined) {
         return {
             name: dimensionName,
-            status: "mismatch",
-            message: `expected ${expected === undefined ? "present" : "absent"}, actual ${actual === undefined ? "absent" : "present"}`,
-            evidence_ids: [],
+            status: "unknown",
+            message: "one side has no observed value",
+            evidence_ids: resultEvidenceIds,
         };
     }
     // Semantic comparison for structured objects
@@ -99,14 +222,14 @@ export function compareDimension(dimensionName, expected, actual, options = {})
                 name: dimensionName,
                 status: "match",
                 message: "",
-                evidence_ids: [],
+                evidence_ids: resultEvidenceIds,
             };
         }
         return {
             name: dimensionName,
             status: "mismatch",
             message: "semantic content differs",
-            evidence_ids: [],
+            evidence_ids: resultEvidenceIds,
         };
     }
     // Primitive comparison
@@ -115,14 +238,14 @@ export function compareDimension(dimensionName, expected, actual, options = {})
             name: dimensionName,
             status: "match",
             message: "",
-            evidence_ids: [],
+            evidence_ids: resultEvidenceIds,
         };
     }
     return {
         name: dimensionName,
         status: "mismatch",
         message: `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,
-        evidence_ids: [],
+        evidence_ids: resultEvidenceIds,
     };
 }
 /** Recursively sort object keys for deterministic comparison. */
@@ -131,6 +254,8 @@ function sortKeys(value) {
         return value;
     if (Array.isArray(value))
         return value.map(sortKeys);
+    if (!isRecord(value))
+        return value;
     const sorted = {};
     for (const key of Object.keys(value).sort()) {
         sorted[key] = sortKeys(value[key]);
@@ -144,12 +269,22 @@ function sortKeys(value) {
 export function evaluateTrustGate(contract, expectedEvidence, actualEvidence, options = {}) {
     const dimensionResults = [];
     let firstDivergence = null;
+    const expectedView = evidenceView(expectedEvidence);
+    const actualView = evidenceView(actualEvidence);
     for (const dim of contract.dimensions) {
         if (!dim.required)
             continue;
-        const expectedValue = expectedEvidence[dim.name];
-        const actualValue = actualEvidence[dim.name];
-        const result = compareDimension(dim.name, expectedValue, actualValue, options);
+        const expectedValue = expectedView.values[dim.name];
+        const actualValue = actualView.values[dim.name];
+        const result = compareDimension(dim.name, expectedValue, actualValue, {
+            ...options,
+            expected_status: statusForDimension(expectedView, dim.name),
+            actual_status: statusForDimension(actualView, dim.name),
+            evidence_ids: uniqueStrings([
+                ...actualView.evidence_ids,
+                ...expectedView.evidence_ids,
+            ]),
+        });
         dimensionResults.push(result);
         if (result.status === "mismatch" && firstDivergence === null) {
             firstDivergence = {

package/dist/domain/customProtocolCapture.js

@@ -129,9 +129,9 @@ export function failedAuthEvents(events) {
 }
 /** Compute the duration of an authentication flow in milliseconds. */
 export function authFlowDuration(events) {
-    if (events.length === 0)
+    const first = events.at(0);
+    const last = events.at(-1);
+    if (first === undefined || last === undefined)
         return null;
-    const first = events[0];
-    const last = events[events.length - 1];
     return last.at_ms - first.at_ms;
 }