rea-agents 6.0.0 → 6.2.0

package/dist/contracts/browserScenarioToolContracts.js

@@ -1,5 +1,5 @@
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
 import { browserScenarioInputSchema } from "../domain/browserScenario.js";
 import { browserScenarioCaptureSchema } from "../domain/browserScenarioCapture.js";
 const example = {

package/dist/contracts/browserToolContracts.js

@@ -1,21 +1,20 @@
-import { browserTargetListSchema, inspectWebPageInputSchema, listBrowserTargetsInputSchema, webPageInspectionSchema, } from "../domain/browserObservation.js";
+import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "../domain/browserObservation.js";
+import { browserTargetListSchema, webPageInspectionSchema, } from "../domain/browserObservationSchemas.js";
 import { analyzeWebBundleInputSchema, webBundleAnalysisSchema, } from "../domain/webBundleAnalysis.js";
 import { observeWebSessionInputSchema, webObservationSessionSchema, } from "../domain/browserSession.js";
 import { discoverWebMcpToolsInputSchema, webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
-import { browserCaptureComparisonSchema } from "../domain/browserCaptureComparison.js";
+import { browserCaptureComparisonInputSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
-import { browserCaptureToolInputSchema } from "./browserCaptureToolInputSchema.js";
-const evidenceResult = evidenceResultOf;
-const listOutputSchema = evidenceResult(browserTargetListSchema);
-const inspectionOutputSchema = evidenceResult(webPageInspectionSchema);
-const bundleOutputSchema = evidenceResult(webBundleAnalysisSchema);
-const observationSessionOutputSchema = evidenceResult(webObservationSessionSchema);
-const webMcpOutputSchema = evidenceResult(webMcpDiscoverySchema);
-const captureDiffOutputSchema = evidenceResult(browserCaptureComparisonSchema);
-const screenshotOutputSchema = evidenceResult(webScreenshotSchema);
-const screenshotDiffOutputSchema = evidenceResult(webScreenshotDiffSchema);
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+const listOutputSchema = evidenceResultOf(browserTargetListSchema);
+const inspectionOutputSchema = evidenceResultOf(webPageInspectionSchema);
+const bundleOutputSchema = evidenceResultOf(webBundleAnalysisSchema);
+const observationSessionOutputSchema = evidenceResultOf(webObservationSessionSchema);
+const webMcpOutputSchema = evidenceResultOf(webMcpDiscoverySchema);
+const captureDiffOutputSchema = evidenceResultOf(browserCaptureComparisonSchema);
+const screenshotOutputSchema = evidenceResultOf(webScreenshotSchema);
+const screenshotDiffOutputSchema = evidenceResultOf(webScreenshotDiffSchema);
 const endpoint = "http://127.0.0.1:9222";
 const origin = "https://app.example.test";
 const scenarioUrl = {
@@ -50,6 +49,11 @@ const exampleScenarioCapture = () => ({
         start_origin: origin,
         action_count: 1,
         secret_references: [],
+        network_content: {
+            request_body: false,
+            response_body: false,
+            header_values: false,
+        },
     },
     duration_ms: 10,
     steps: [
@@ -182,9 +186,9 @@ export const BROWSER_TOOL_CONTRACTS = [
     {
         name: "compare_web_captures",
         ...toolContractMetadata("compare_web_captures"),
-        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page result in inspection and an optional complete discover_webmcp_tools result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario results in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
+        description: "Compare passive web captures by providing before and after, each with the complete inspect_web_page normalized_result in inspection and an optional complete discover_webmcp_tools normalized_result in webmcp; or compare recorded scenarios by passing complete capture_browser_scenario normalized_result objects in before_scenario and after_scenario with an optional normalization policy. Use exactly one input group. Scenario comparison aligns exact step IDs, records deterministic literal normalization, and returns every artifact-level difference plus alignment failures inline. Missing or truncated evidence never proves equality.",
         kind: "browser-provider",
-        inputSchema: browserCaptureToolInputSchema,
+        inputSchema: browserCaptureComparisonInputSchema,
         outputSchema: captureDiffOutputSchema,
         examples: [
             {

package/dist/contracts/enhancedInputs.js

@@ -18,18 +18,20 @@ export const enhancedInputSchemas = {
             .default([]),
     }),
     get_call_graph: z.strictObject({
-        address: z.string().describe("A provider-normalized procedure address"),
+        address: z
+            .string()
+            .describe("A procedure symbol or address to resolve to its canonical entry"),
         direction: z.enum(["forward", "backward"]).default("forward"),
     }),
     analyze_swift_types: z.strictObject({
         category: z
             .enum(["classes", "structs", "enums", "protocols", "extensions", "other"])
             .optional()
-            .describe("Limit results to one Swift symbol category."),
+            .describe("Limit categorized results to one Swift category; unresolved category observations remain in unclassified."),
         pattern: z
             .string()
             .optional()
-            .describe("Case-sensitive literal filter applied to mangled symbol names."),
+            .describe("Case-sensitive literal filter applied to provider procedure names and their supporting Swift manglings."),
     }),
     find_xrefs_to_name: z.strictObject({ name: z.string() }),
     binary_overview: z.strictObject({}),
@@ -41,10 +43,10 @@ export const enhancedInputSchemas = {
     }),
     trace_feature: traceLiteralInputSchema,
     trace_call_path: z.strictObject({
-        start: z.string().describe("A provider-normalized procedure address"),
+        start: z.string().describe("A starting procedure symbol or address"),
         goal: z
             .string()
-            .describe("An optional provider-normalized destination address")
+            .describe("An optional destination procedure symbol or address")
             .optional(),
         direction: z.enum(["forward", "backward"]).default("forward"),
     }),

package/dist/contracts/enhancedToolContracts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { enhancedInputSchemas } from "./enhancedInputs.js";
-import { enhancedOutputSchemas, requireOutputSchema, } from "./toolOutputSchemas.js";
+import { enhancedOutputSchemas } from "./toolOutputSchemaGroups.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 import { examplesFor } from "./toolContractHelpers.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { FUNCTION_WORKFLOW_TOOL_CONTRACTS } from "./functionWorkflowToolContracts.js";
@@ -18,14 +19,14 @@ export const ENHANCED_TOOL_CONTRACTS = [
     enhanced("inspect_native_dispatch_metadata", "Inspect the bound provider's name inventory for Objective-C class/method symbols and Swift mangled symbols, returning at most max_records decoded names. Includes target SHA-256 when available, provider identity/version, analysis-profile digest, facet coverage, and per-record Evidence. This is symbol-level evidence, not runtime metadata: ivar layouts, protocol conformances, witness/class tables, and relative pointers are explicitly marked unsupported unless a provider supplies those decoders. The provider controls how its name inventory is acquired.", enhancedInputSchemas.inspect_native_dispatch_metadata),
     enhanced("get_objc_classes", "Discover and deduplicate Objective-C class labels, optionally filtering by literal substring.", enhancedInputSchemas.get_objc_classes),
     enhanced("get_objc_protocols", "Discover and deduplicate Objective-C and Swift protocol labels.", enhancedInputSchemas.get_objc_protocols),
-    enhanced("batch_decompile", "Decompile each explicit procedure symbol or address concurrently. Returns ordered per-item success or error results and aggregate counts.", enhancedInputSchemas.batch_decompile),
-    enhanced("get_call_graph", "Traverse the bound provider's caller or callee relationships from one symbol or address until the reachable graph is exhausted. Every node has an ok/error status and failures use safe typed projections; unresolved indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph),
-    enhanced("analyze_swift_types", 'Categorize analyzed procedure names into Swift classes, structs, enums, protocols, extensions, and other symbols. Returns deduplicated names grouped with counts. Optionally select one category and/or apply a case-sensitive literal name filter; for example, use {category: "classes", pattern: "Account"} to find matching class symbols.', enhancedInputSchemas.analyze_swift_types),
+    enhanced("batch_decompile", "Decompile each explicit procedure symbol or address concurrently. Preserves each input selector in address and reports the observed canonical entry and entry label in procedure; identity or label failures remain explicit without discarding usable pseudocode. Returns ordered per-item success or error results and aggregate counts.", enhancedInputSchemas.batch_decompile),
+    enhanced("get_call_graph", "Resolve one symbol or address to its canonical procedure entry, then traverse the bound provider's caller or callee relationships until the reachable graph is exhausted. Every node uses a canonical address and has an ok/error status; failures use safe typed projections. Unresolved indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph),
+    enhanced("analyze_swift_types", 'Categorize analyzed Swift procedure names using their manglings or same-address Swift symbol aliases. Decodes legacy and literal modern nominal contexts into classes, structs, enums, protocols, and extensions. Preserves provider names and supporting mangled_names; unresolved categories appear in other and in unclassified, which remains inline even under category filters. Returns deduplicated procedure-name counts, not unique source types, plus identification limitations. Optionally select one category and/or apply a case-sensitive literal filter to provider names or supporting manglings; for example, use {category: "structs", pattern: "Pair"}.', enhancedInputSchemas.analyze_swift_types),
     enhanced("find_xrefs_to_name", "Resolve an exact name against the bound provider's name inventory and return a resolved or unresolved result. Unresolved names use the stable name_not_found reason; this xref workflow returns address-only projections.", enhancedInputSchemas.find_xrefs_to_name),
     enhanced("binary_overview", "Return native-binary metadata, every segment with its length, and exhaustive procedure/string counts. Use search_procedures, list_procedures, or analyze_function directly when you already know which procedure to inspect.", enhancedInputSchemas.binary_overview),
     ...FUNCTION_WORKFLOW_TOOL_CONTRACTS,
-    enhanced("trace_feature", "Trace a literal feature query through every matching string and procedure, their xrefs, and truthful containing-procedure resolution. Returns observations, operation count, and residual unknowns without inferring reference kinds.", enhancedInputSchemas.trace_feature),
-    enhanced("trace_call_path", "Trace direct callers or callees from one exact procedure address until the graph is exhausted or the optional goal is reached. Returns visited nodes, direct-call edges, a shortest traversal path, provider failures, and residual unknowns; unresolved indirect calls remain unknown.", enhancedInputSchemas.trace_call_path),
+    enhanced("trace_feature", "Trace the complete literal query, preserving spaces, through every matching string and procedure, their xrefs, and truthful containing-procedure resolution. Returns observations, operation count, and residual unknowns without inferring reference kinds.", enhancedInputSchemas.trace_feature),
+    enhanced("trace_call_path", "Resolve start and optional goal symbols or addresses to canonical procedure entries, then trace direct callers or callees until the graph is exhausted or the goal is reached. Results use canonical addresses; Evidence preserves supplied selectors. Returns visited nodes, direct-call edges, a shortest traversal path, provider failures, and residual unknowns; unresolved indirect calls remain unknown.", enhancedInputSchemas.trace_call_path),
     enhanced("trace_native_ui_action", "Trace one unique compiled UI action, object ID, native symbol or exact function address through authored connections, encoded or symbolized Objective-C handlers, and bounded static call references. Typed direct and resolved indirect calls, ambiguous candidates, inferred untyped provider callees, and targetless sites remain distinct. Runtime reachability is unknown; use trace_native_values for recovered value dependencies.", enhancedInputSchemas.trace_native_ui_action),
     enhanced("trace_native_values", "Trace a bounded static dependency graph from one explicit native procedure. Includes high-p-code def-use, constants, operators, memory and branch operations, resolved call edges, and derived argument/parameter and return/output bindings. Missing bindings, alias semantics, persistent state and RNG roles remain unknown. Budgets bound depth, decompilations, graph size and payloads; nodes are paginated.", enhancedInputSchemas.trace_native_values),
 ];

package/dist/contracts/evm/evmToolContracts.js

@@ -1,6 +1,6 @@
 import { inspectEvmInterfaceInputSchema, evmInterfaceSchema, } from "../../domain/evm/evmInterface.js";
 import { toolContractMetadata } from "../toolEffects.js";
-import { evidenceResultOf } from "../toolOutputSchemas.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
 /** Target-free EVM capabilities are independent of archive/Apple artifact providers. */
 export const EVM_TOOL_CONTRACTS = [
     {

package/dist/contracts/functionWorkflowToolContracts.js

@@ -2,7 +2,7 @@ import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { enhancedInputSchemas } from "./enhancedInputs.js";
 import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { enhancedOutputSchemas } from "./toolOutputSchemas.js";
+import { enhancedOutputSchemas } from "./toolOutputSchemaGroups.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 const functionWorkflow = (name, description) => {
     const inputSchema = enhancedInputSchemas[name];

package/dist/contracts/hopperMemoryContracts.js

@@ -1,8 +1,5 @@
 import { z } from "zod";
-const document = z.string().optional().describe("The document name");
-const address = z
-    .string()
-    .describe("A provider-normalized address; default memory uses 0x-prefixed hexadecimal");
+import { address, document } from "./toolContractHelpers.js";
 /** Hopper memory and file-mapping contracts. */
 export const HOPPER_MEMORY_TOOL_DEFINITIONS = [
     {
@@ -16,7 +13,7 @@ export const HOPPER_MEMORY_TOOL_DEFINITIONS = [
     },
     {
         name: "address_to_file_offset",
-        description: "Map one provider-normalized virtual address to its original nonnegative file offset. Unmapped addresses fail explicitly, and providers without an authoritative mapping API return typed capability unavailability.",
+        description: "Map one provider-normalized virtual address to its original nonnegative file offset. Hopper verifies the original bytes against the selected executable digest and translates FAT image-relative offsets using the loaded header. Results preserve the provider coordinate, image base, and source path. Unmapped addresses fail explicitly; changed or unavailable sources return typed errors retaining native mapping facts as partial evidence.",
         inputSchema: z.object({ address, document }),
     },
 ];

package/dist/contracts/inputSchemaPresentation.js

@@ -0,0 +1,90 @@
+const schemaMaps = new Set([
+    "$defs",
+    "definitions",
+    "properties",
+    "patternProperties",
+    "dependentSchemas",
+    "dependencies",
+]);
+const schemaArrays = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+const schemaChildren = new Set([
+    "items",
+    "additionalItems",
+    "contains",
+    "additionalProperties",
+    "unevaluatedProperties",
+    "unevaluatedItems",
+    "propertyNames",
+    "not",
+    "if",
+    "then",
+    "else",
+]);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const resolveReference = (root, reference) => {
+    if (!reference.startsWith("#/"))
+        return undefined;
+    let value = root;
+    for (const token of reference.slice(2).split("/")) {
+        const key = token.replaceAll("~1", "/").replaceAll("~0", "~");
+        if (!isObject(value) || !Object.hasOwn(value, key))
+            return undefined;
+        value = value[key];
+    }
+    return value;
+};
+const referencedDescription = (root, schema) => {
+    let value = schema;
+    const active = new Set();
+    while (isObject(value)) {
+        if (typeof value.description === "string")
+            return value.description;
+        if (typeof value.$ref !== "string" || active.has(value.$ref))
+            return undefined;
+        active.add(value.$ref);
+        value = resolveReference(root, value.$ref);
+    }
+    return undefined;
+};
+const describeSchema = (schema, root, describeProperty) => {
+    if (!isObject(schema))
+        return schema;
+    return Object.fromEntries(Object.entries(schema).map(([key, value]) => {
+        if (schemaMaps.has(key) && isObject(value))
+            return [
+                key,
+                Object.fromEntries(Object.entries(value).map(([name, child]) => {
+                    const described = describeSchema(child, root, describeProperty);
+                    return [
+                        name,
+                        key === "properties" && isObject(described)
+                            ? {
+                                ...described,
+                                description: referencedDescription(root, described) ??
+                                    describeProperty(name),
+                            }
+                            : described,
+                    ];
+                })),
+            ];
+        if (schemaArrays.has(key) && Array.isArray(value))
+            return [
+                key,
+                value.map((child) => describeSchema(child, root, describeProperty)),
+            ];
+        if (schemaChildren.has(key))
+            return [
+                key,
+                Array.isArray(value)
+                    ? value.map((child) => describeSchema(child, root, describeProperty))
+                    : describeSchema(value, root, describeProperty),
+            ];
+        // Annotation values and literal const/enum data are not schemas.
+        return [key, value];
+    }));
+};
+/** Describe canonical input fields without changing structural constraints. */
+export const presentInputJsonSchema = (root, describeProperty) => {
+    const described = describeSchema(root, root, describeProperty);
+    return isObject(described) ? described : root;
+};

package/dist/contracts/investigationExamples.js

@@ -1,9 +1,10 @@
-import { compareFunctions } from "../domain/functionComparison.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { compareProcessCaptures, parseProcessCapture, } from "../domain/process/processCapture.js";
+import { compareProcessCaptures } from "../domain/process/processComparison.js";
+import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
 import { FUNCTION_COMPARISON_EXAMPLE } from "./functionComparisonExample.js";
-import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "./process/processCaptureExample.js";
+import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../domain/process/processCaptureExample.js";
+import { compareFunctions } from "../domain/functionComparison.js";
 const comparison = compareFunctions(FUNCTION_COMPARISON_EXAMPLE.left, FUNCTION_COMPARISON_EXAMPLE.right);
 export const FUNCTION_COMPARISON_EVIDENCE = createEvidence(undefined, {
     id: "rea-function-comparison",

package/dist/contracts/javascript/electronToolContracts.js

@@ -1,5 +1,5 @@
 import { toolContractMetadata } from "../toolEffects.js";
-import { evidenceResultOf } from "../toolOutputSchemas.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
 import { electronPageInspectionSchema, electronTargetListSchema, inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../../domain/javascript/electronObservation.js";
 import { electronActiveObservationInputSchema, electronActiveObservationResultSchema, } from "../../domain/javascript/electronActiveObservation.js";
 import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
@@ -85,7 +85,7 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "capture_electron_scenario",
         ...toolContractMetadata("capture_electron_scenario"),
-        description: "Use this for a provider-owned Electron run when passive CDP or Inspector observation cannot exercise application behavior. REA owns startup and teardown, accepts caller-defined click/wait actions plus window-targeted renderer reload/crash and synthetic open-url/second-instance delivery, and returns correlated window/WebContents/process/preload/session/navigation/shell/IPC evidence without retaining payload values. Results identify observed and unavailable event families, coverage status, action targets, and truncation. External shell, navigation, permission, download, popup, updater, and OS-integration effects are blocked and recorded. Use passive Electron tools for observation-only work.",
+        description: "Use this for a provider-owned Electron run when passive CDP or Inspector observation cannot exercise application behavior. REA owns startup and teardown, accepts caller-defined click/wait actions plus window-targeted renderer reload/crash and synthetic open-url/second-instance delivery, and returns correlated window/WebContents/process/preload/session/navigation/shell/IPC evidence without retaining payload values. Actions wait for completion or request cancellation; a missing click target can keep the request pending. Results identify observed and unavailable event families, coverage status, action targets, and truncation. Cleanup failures retain collected observations with explicit cleanup uncertainty. External shell, navigation, permission, download, popup, updater, and OS-integration effects are blocked and recorded. Use passive Electron tools for observation-only work.",
         kind: "electron-provider",
         inputSchema: electronActiveObservationInputSchema,
         outputSchema: evidenceResultOf(electronActiveObservationResultSchema),

package/dist/contracts/javascript/javascriptApplicationWorkflowExamples.js

@@ -82,23 +82,3 @@ export const SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE = {
     }),
     application: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
 };
-/** Exact static return-shape comparison with both Evidence records inline. */
-export const JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE = {
-    left: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
-    right: reconciliationEvidence,
-    left_module_path: "parser.mjs",
-    left_export_name: "default",
-    right_module_path: "parser.mjs",
-    right_export_name: "default",
-};
-/** Full-Evidence compatibility fixture used by pure domain and adapter tests. */
-export const JAVASCRIPT_FEATURE_TRACE_FULL_EVIDENCE_EXAMPLE = {
-    application: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
-    seed: TRACE_SEED,
-    direction: "both",
-};
-/** Full-Evidence compatibility comparison fixture. */
-export const JAVASCRIPT_VERSION_COMPARISON_FULL_EVIDENCE_EXAMPLE = {
-    left: JAVASCRIPT_APPLICATION_EVIDENCE_EXAMPLE,
-    right: reconciliationEvidence,
-};

package/dist/contracts/javascript/javascriptExportShapeComparisonExample.js

@@ -0,0 +1,245 @@
+import { createEvidence } from "../../domain/evidence.js";
+import { createWebTextArtifact } from "../../domain/webContentArtifact.js";
+import { analyzeJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
+import { projectJavaScriptExportReturnShapes } from "../../domain/javascript/javascriptExportReturnShapeProjection.js";
+import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
+import { createJavaScriptApplicationGraph, createJavaScriptApplicationNode, } from "../../domain/javascript/javascriptApplicationGraph.js";
+import { createJavaScriptSemanticGraph, createJavaScriptSemanticGraphNode, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
+import { javascriptApplicationAnalysisResultSchema } from "../../domain/javascript/javascriptApplicationAnalysis.js";
+// Inventory identities/counters captured from real analysis of these two sources.
+// The inline example retains only source-derived export facts, with explicit gaps.
+const captures = {
+    count: {
+        input_path: "/examples/javascript-export-presence/left",
+        root_artifact_sha256: "5005ebc2f35719a2fc014f19a81c669f3a1ab471b7245ef6985a111b6845a747",
+        inventory_manifest_id: "agm_f30ded9a83d43a3980417bbe63dfad569e83386f243c4d6a01af0166372cb9e6",
+        inventory_graph_sha256: "4b8aceaf67e43fd8317ec1f5fd1df5235f8fa402335accf011683e008c6bc62c",
+    },
+    total: {
+        input_path: "/examples/javascript-export-presence/right",
+        root_artifact_sha256: "269ae72a601ad5ac02f1c2dda6ff9accffa2d2e4f4a9e406facee0d5a78a5377",
+        inventory_manifest_id: "agm_d3ceaa1af38fb3474070ca25c0d4644282e5fb7d5824cee3e3a81391481e9fc1",
+        inventory_graph_sha256: "3e9bc926951480c35385efe5650d9d781631bd74c37a523d543b5fbe06b01ce6",
+    },
+};
+const summary = {
+    browser_windows: 0,
+    explicit_web_preferences: 0,
+    preload_entrypoints: 0,
+    context_bridge_apis: 0,
+    exposed_api_members: 0,
+    ipc: {
+        operations: 0,
+        literal_channels: 0,
+        dynamic_channel_operations: 0,
+        renderer_transmissions: 0,
+        renderer_listeners: 0,
+        main_handlers: 0,
+        paired_renderer_transmissions: 0,
+        ambiguous_renderer_transmissions: 0,
+        unpaired_literal_renderer_transmissions: 0,
+    },
+    sender_validation_observations: 0,
+    utility_processes: 0,
+    resolved_utility_entrypoints: 0,
+    native_addon_bindings: 0,
+    resolved_native_addon_bindings: 0,
+};
+const statistics = {
+    relevant_files: 1,
+    nested_asar_containers: 0,
+    text_bytes_read: 60,
+    invalid_utf8_files: 0,
+    parsed_javascript_files: 1,
+    visited_ast_nodes: 12,
+    findings: 1,
+    modules: 0,
+    parse_failures: 0,
+    truncated_scopes: 0,
+};
+const modulePath = "parser.mjs";
+const limitations = [
+    "This example retains export and return-shape facts only; other application and semantic relationships are omitted.",
+];
+const exampleEvidence = (property) => {
+    const metadata = captures[property];
+    const source = `export default () => ({ kind: "results", ${property}: query() });\n`;
+    const artifact = createWebTextArtifact(source, "text/javascript");
+    const ir = analyzeJavaScriptSemantics(source);
+    const link = ir.moduleLinks.find(({ exportedName }) => exportedName === "default");
+    if (link === undefined)
+        throw new Error("Example source must define a default export");
+    const coverage = ir.coverage.status === "complete"
+        ? completeApplicationCoverage()
+        : partialApplicationCoverage([], ir.coverage.omittedCount);
+    const projection = projectJavaScriptExportReturnShapes({
+        ir,
+        link,
+        modulePath,
+        baseCoverage: coverage,
+    });
+    if (projection === null)
+        throw new Error("Example export must retain return shapes");
+    const evidence = {
+        artifact: {
+            available: true,
+            artifact_id: `art_${artifact.sha256}`,
+            sha256: artifact.sha256,
+        },
+        location: {
+            available: true,
+            value: { kind: "source-range", source: modulePath, ...link.location },
+        },
+        extractor: {
+            name: "rea-javascript-artifact-reconstruction",
+            version: "1",
+            operation: "recover-module-export",
+            executable_sha256: null,
+        },
+        coverage,
+        limitations: ir.limitations,
+        evidence_ids: [],
+    };
+    const exported = createJavaScriptApplicationNode({
+        kind: "javascript-module",
+        identity: {
+            strategy: "artifact-local-key",
+            stability: "artifact-version",
+            artifact_sha256: artifact.sha256,
+            namespace: "module-export",
+            key: `${metadata.root_artifact_sha256}:${modulePath}:default`,
+        },
+        observations: [
+            {
+                label: `${modulePath}:default`,
+                properties: {
+                    semantic_role: "export-binding",
+                    module_path: modulePath,
+                    relationship_kind: link.kind,
+                    exported_name: link.exportedName,
+                    local_name: link.localName,
+                    imported_name: link.importedName,
+                    declared_specifier: link.specifier,
+                },
+                evidence: {
+                    ...evidence,
+                    authority: "ast-static-analysis",
+                    state: "observed",
+                    confidence: "exact",
+                },
+            },
+            {
+                label: `${modulePath}:default:return-shapes`,
+                properties: projection.properties,
+                evidence: {
+                    ...evidence,
+                    authority: "static-relationship-inference",
+                    state: "inferred",
+                    confidence: "high",
+                    location: {
+                        available: true,
+                        value: {
+                            kind: "source-range",
+                            source: modulePath,
+                            ...projection.range,
+                        },
+                    },
+                    extractor: {
+                        ...evidence.extractor,
+                        operation: "recover-export-return-shapes",
+                    },
+                    coverage: projection.coverage,
+                    limitations: projection.limitations,
+                },
+            },
+        ],
+    });
+    const graph = createJavaScriptApplicationGraph({
+        schema: "JavaScriptApplicationGraph",
+        root_node_ids: [exported.node_id],
+        nodes: [exported],
+        edges: [],
+        coverage: partialApplicationCoverage([], null),
+        limitations,
+    });
+    const module = createJavaScriptSemanticGraphNode({
+        kind: "module",
+        identity: {
+            artifact_sha256: artifact.sha256,
+            module_path: modulePath,
+            source_range: null,
+            role_key: "example-module",
+        },
+        function_node_id: null,
+        application_node_ids: [exported.node_id],
+        label: modulePath,
+        properties: {},
+        evidence: {
+            ...evidence,
+            authority: "ast-static-analysis",
+            state: "observed",
+            confidence: "exact",
+        },
+    });
+    const semanticGraph = createJavaScriptSemanticGraph({
+        schema: "JavaScriptSemanticRelationGraph",
+        root_artifact_sha256: metadata.root_artifact_sha256,
+        application_graph_id: graph.graph_id,
+        root_node_ids: [module.node_id],
+        nodes: [module],
+        relations: [],
+        fingerprints: [],
+        unknowns: [],
+        coverage: {
+            status: "unknown",
+            truncated: false,
+            omitted_nodes: null,
+            omitted_relations: null,
+            limits: [],
+            families: JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => ({
+                family,
+                status: "unknown",
+                retained_relations: 0,
+                omitted_relations: null,
+                unknown_ids: [],
+            })),
+        },
+        limitations,
+    });
+    const result = javascriptApplicationAnalysisResultSchema.parse({
+        ...metadata,
+        format: "directory",
+        graph,
+        semantic_graph: semanticGraph,
+        summary,
+        statistics,
+        limitations,
+    });
+    return createEvidence({
+        path: result.input_path,
+        sha256: result.root_artifact_sha256,
+        format: "directory",
+    }, {
+        id: "rea-javascript-application",
+        name: "REA JavaScript application analyzer",
+        version: "1",
+    }, {
+        predicateType: "rea.javascript-application-analysis",
+        operation: "analyze_javascript_application",
+        parameters: {},
+        result,
+        confidence: "derived",
+        authority: "shipped-artifact",
+        limitations,
+    });
+};
+/** Source-derived tagged exports with known presence and unresolved values. */
+export const JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE = {
+    left: exampleEvidence("count"),
+    right: exampleEvidence("total"),
+    left_module_path: modulePath,
+    left_export_name: "default",
+    right_module_path: modulePath,
+    right_export_name: "default",
+};

package/dist/contracts/javascript/javascriptRuntimeObservationToolContracts.js

@@ -1,5 +1,5 @@
 import { toolContractMetadata } from "../toolEffects.js";
-import { evidenceResultOf } from "../toolOutputSchemas.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
 import { javascriptRuntimeObservationSchema, javascriptRuntimeTargetListSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "../../domain/javascript/javascriptRuntimeObservation.js";
 const endpoint = "http://127.0.0.1:9229";
 /** Passive Node/Electron V8 Inspector discovery and observation contracts. */

package/dist/contracts/managed/managedToolContracts.js

@@ -1,24 +1,17 @@
 import { z } from "zod";
-import { managedOutputSchemas } from "../toolOutputSchemas.js";
+import { managedOutputSchemas } from "../toolOutputSchemaGroups.js";
 import { toolContractMetadata } from "../toolEffects.js";
 import { requireOutputSchema } from "../toolOutputSchemaPrimitives.js";
-import { isAbsoluteLocalPath } from "../../domain/localPath.js";
+import { isAbsoluteLocalPath, localPathStringSchema, } from "../../domain/localPath.js";
 /** Exact caller boundary for execution-free PE/CLI triage and identity. */
-const managedTargetInputSchema = z.strictObject({
-    path: z
-        .string()
-        .min(1)
+export const managedTargetInputSchema = z.strictObject({
+    path: localPathStringSchema
         .refine(isAbsoluteLocalPath, {
         message: "path must be an absolute local filesystem path (for example /tmp/Example.dll or C:\\Example.dll)",
     })
         .describe("Explicit absolute managed PE/CLI path; omit to reuse the previously selected managed target")
         .optional(),
 });
-export const managedArtifactInputSchema = managedTargetInputSchema;
-/** Exact caller boundary for execution-free metadata/signature/IL inspection. */
-export const managedMemberInputSchema = managedTargetInputSchema;
-/** Exact caller boundary for execution-free managed/native boundary inspection. */
-export const managedNativeBoundaryInputSchema = managedTargetInputSchema;
 const outputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_artifact");
 const memberOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_members");
 const nativeBoundaryOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_native_boundaries");
@@ -29,7 +22,7 @@ export const MANAGED_TOOL_CONTRACTS = [
         ...toolContractMetadata("inspect_managed_artifact"),
         description: "Open and classify an explicit managed PE/CLI path, or inspect the active managed target, then inventory exact assembly/module identity, target framework evidence, references, resources, and custom attributes without loading or executing target code. Returns complete inline inventories when metadata is admitted and explicit partial or malformed coverage otherwise.",
         kind: "managed-provider",
-        inputSchema: managedArtifactInputSchema,
+        inputSchema: managedTargetInputSchema,
         outputSchema,
         examples: [
             {
@@ -43,7 +36,7 @@ export const MANAGED_TOOL_CONTRACTS = [
         ...toolContractMetadata("inspect_managed_members"),
         description: "Inspect PE/CLI metadata members, signatures, raw CIL hashes, decoded-instruction-tuple hashes, separately reported exception regions, call edges, and field-access anchors without loading or executing target code. Metadata tokens are reported as build-local coordinates bound to the artifact SHA-256 and MVID; the tuple hash does not resolve them or fully commit control flow.",
         kind: "managed-provider",
-        inputSchema: managedMemberInputSchema,
+        inputSchema: managedTargetInputSchema,
         outputSchema: memberOutputSchema,
         examples: [
             {
@@ -57,7 +50,7 @@ export const MANAGED_TOOL_CONTRACTS = [
         ...toolContractMetadata("inspect_managed_native_boundaries"),
         description: "Inspect PE/CLI ModuleRef, ImplMap/PInvoke declarations, CLI native-header indicators, and non-IL method implementation flags without loading or executing target code. Results are managed declarations and degraded native-boundary observations, not verified native exports or addresses.",
         kind: "managed-provider",
-        inputSchema: managedNativeBoundaryInputSchema,
+        inputSchema: managedTargetInputSchema,
         outputSchema: nativeBoundaryOutputSchema,
         examples: [
             {