rea-agents 6.1.0 → 6.2.0

package/dist/config/parseConfig.js

@@ -1,9 +1,9 @@
 import { accessSync, constants } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { ConfigurationError } from "../domain/configurationErrors.js";
 import { ok } from "../domain/result.js";
 import { parseEnvironment } from "./environment.js";
+import { homeDirectoryFromEnvironment } from "./homeDirectory.js";
 import { parseStringArray, parseLoaderArgs } from "./parsers.js";
 const DEFAULT_HOPPER_LAUNCHER_PATH = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
 const SYSTEM_LINUX_HOPPER = "/opt/hopper/bin/Hopper";
@@ -16,7 +16,7 @@ const executableAvailable = (path) => {
         return false;
     }
 };
-const defaultHopperLauncherPath = (platform = process.platform, homeDirectory = homedir(), executable = executableAvailable) => {
+const defaultHopperLauncherPath = (platform, homeDirectory, executable = executableAvailable) => {
     if (platform !== "linux")
         return DEFAULT_HOPPER_LAUNCHER_PATH;
     if (executable(SYSTEM_LINUX_HOPPER))
@@ -37,6 +37,9 @@ export const parseConfig = (environment) => {
     if (!secretPatterns.ok)
         return secretPatterns;
     return ok({
+        ...(env.REA_MCP_MAX_RESPONSE_BYTES === undefined
+            ? {}
+            : { mcpMaxResponseBytes: env.REA_MCP_MAX_RESPONSE_BYTES }),
         analysisProvider: env.REA_ANALYSIS_PROVIDER,
         ...(env.REA_IDA_MCP_CONFIG === undefined
             ? {}
@@ -48,7 +51,8 @@ export const parseConfig = (environment) => {
             ? {}
             : { ghidraNativeAotJar: env.REA_GHIDRA_NATIVEAOT_JAR }),
         ilspyCmdPath: env.REA_ILSPY_CMD_PATH,
-        hopperLauncherPath: env.HOPPER_LAUNCHER_PATH ?? defaultHopperLauncherPath(),
+        hopperLauncherPath: env.HOPPER_LAUNCHER_PATH ??
+            defaultHopperLauncherPath(process.platform, homeDirectoryFromEnvironment(environment, process.platform)),
         hopperTargetPath: env.HOPPER_TARGET_PATH,
         hopperTargetKind: env.HOPPER_TARGET_KIND,
         hopperLoaderArgs: loaderArgs.value,

package/dist/config/parsers.js

@@ -1,33 +1,30 @@
 import { z } from "zod";
 import { ConfigurationError } from "../domain/configurationErrors.js";
 import { err, ok } from "../domain/result.js";
+import { safeParseJson } from "../domain/safeJson.js";
+/** Decode explicitly selected reference-source exclusion patterns. */
 export const parseStringArray = (encoded, name) => {
-    try {
-        const parsed = z.array(z.string().min(1)).safeParse(JSON.parse(encoded));
-        return parsed.success
-            ? ok(parsed.data)
-            : err(new ConfigurationError(`${name} must encode an array of strings`, {
-                cause: parsed.error,
-            }));
-    }
-    catch (cause) {
-        return err(new ConfigurationError(`${name} must be valid JSON`, { cause }));
-    }
+    return parseConfiguredStringArray(encoded, name, z.string().min(1));
 };
+/** Decode Hopper arguments while preserving meaningful empty argv entries. */
 export const parseLoaderArgs = (encoded) => {
     if (encoded === undefined)
         return ok([]);
-    let decoded;
-    try {
-        decoded = JSON.parse(encoded);
-    }
-    catch (cause) {
-        return err(new ConfigurationError("HOPPER_LOADER_ARGS_JSON must be valid JSON", {
-            cause,
-        }));
-    }
-    const parsed = z.array(z.string()).safeParse(decoded);
+    return parseConfiguredStringArray(encoded, "HOPPER_LOADER_ARGS_JSON", z.string());
+};
+const parseConfiguredStringArray = (encoded, setting, itemSchema) => {
+    const decoded = safeParseJson(encoded);
+    if (!decoded.ok)
+        return err(configuredArrayError(setting, "must be valid JSON", decoded.cause));
+    const parsed = z.array(itemSchema).safeParse(decoded.value);
     return parsed.success
         ? ok(parsed.data)
-        : err(new ConfigurationError("HOPPER_LOADER_ARGS_JSON must encode an array of strings", { cause: parsed.error }));
+        : err(configuredArrayError(setting, "must encode an array of strings", parsed.error));
+};
+const configuredArrayError = (setting, requirement, cause) => {
+    const constraint = `${setting} ${requirement}`;
+    return new ConfigurationError(constraint, {
+        cause,
+        settings: [{ setting, constraint }],
+    });
 };

package/dist/contracts/analysisViewToolContracts.js

@@ -0,0 +1,56 @@
+import { analysisViewResultSchema, inspectAnalysisViewInputSchema, } from "../domain/analysisView/analysisView.js";
+import { toolContractMetadata } from "./toolEffects.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+const RETAINED_EXAMPLE_ID = `ev_${"a".repeat(64)}`;
+/** Selected views of already completed layout and JavaScript analysis Evidence. */
+export const ANALYSIS_VIEW_TOOL_CONTRACTS = [
+    {
+        name: "inspect_analysis_view",
+        ...toolContractMetadata("inspect_analysis_view"),
+        kind: "application",
+        description: "Inspect a selected view of completed binary-layout or JavaScript application Evidence without repeating analysis. Use an exact same-session retained evidence_id or portable inline Evidence. Select a summary, layout mitigations/linkage facet, one section/symbol/module, or a stable page with a positive limit. Module pages contain JavaScript assets, bundled modules and source modules; use node_id when paths are ambiguous or unavailable. Returns selected facts inline with artifact identity, parent Evidence ID, a distinct view digest, coverage, limitations and unknowns. Actual serialized size determines MCP transport admission; choose a smaller page or export the retained Evidence when needed.",
+        inputSchema: inspectAnalysisViewInputSchema,
+        outputSchema: evidenceResultOf(analysisViewResultSchema),
+        examples: [
+            {
+                title: "Summarize retained JavaScript application Evidence",
+                input: {
+                    source: {
+                        kind: "retained-evidence",
+                        evidence_id: RETAINED_EXAMPLE_ID,
+                    },
+                    view: { kind: "summary" },
+                },
+            },
+            {
+                title: "Read one ELF section from retained layout Evidence",
+                input: {
+                    source: {
+                        kind: "retained-evidence",
+                        evidence_id: RETAINED_EXAMPLE_ID,
+                    },
+                    view: {
+                        kind: "item",
+                        collection: "sections",
+                        selector: { name: ".text" },
+                    },
+                },
+            },
+            {
+                title: "Page module identities from retained application Evidence",
+                input: {
+                    source: {
+                        kind: "retained-evidence",
+                        evidence_id: RETAINED_EXAMPLE_ID,
+                    },
+                    view: {
+                        kind: "page",
+                        collection: "modules",
+                        offset: 0,
+                        limit: 32,
+                    },
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/applicationToolContracts.js

@@ -10,8 +10,9 @@ import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedg
 import { androidApplicationProjectionInputSchema, androidApplicationProjectionResultSchema, } from "../domain/android/androidApplication.js";
 import { appleApplicationProjectionInputSchema, appleApplicationProjectionResultSchema, } from "../domain/apple/appleApplication.js";
 import { toolContractMetadata } from "./toolEffects.js";
-import { evidenceResultOf } from "./toolOutputSchemas.js";
-import { JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE, JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE, JAVASCRIPT_FEATURE_TRACE_EXAMPLE, SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE, } from "./javascript/javascriptApplicationWorkflowExamples.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+import { JAVASCRIPT_APPLICATION_VERSION_COMPARISON_EXAMPLE, JAVASCRIPT_FEATURE_TRACE_EXAMPLE, SOURCE_TO_BUNDLE_COMPARISON_EXAMPLE, } from "./javascript/javascriptApplicationWorkflowExamples.js";
+import { JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE } from "./javascript/javascriptExportShapeComparisonExample.js";
 import { ANDROID_APPLICATION_GRAPH_EXAMPLE, APPLE_APPLICATION_GRAPH_EXAMPLE, MACOS_APPLICATION_GRAPH_EXAMPLE, } from "./mobileApplicationGraphExamples.js";
 const traceOutputSchema = evidenceResultOf(applicationFeatureTraceResultSchema);
 const semanticTraceOutputSchema = evidenceResultOf(javaScriptSemanticTraceResultSchema);
@@ -106,13 +107,13 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "compare_javascript_export_shapes",
         ...toolContractMetadata("compare_javascript_export_shapes"),
-        description: "Compare static return shapes for one exact module/export selector on each authenticated JavaScript Application Graph supplied as inline Evidence or exact same-session retained references. Variants pair only by reciprocal unique literal discriminants; dynamic values, incomplete properties, and ambiguous variants remain unknown. Reports JSON Pointer changes without executing JavaScript; runtime behavior requires a separate agent-run probe.",
+        description: "Compare static return shapes for one exact module/export selector on each authenticated JavaScript Application Graph supplied as inline Evidence or exact same-session retained references. Variants pair only by reciprocal unique literal discriminants. Each retained variant lists observed return-property names even when values stay unknown. Presence (present, absent, or unknown-coverage) is separate from value resolution: a name present on only one paired shape is added or removed when parent-property coverage is complete on both sides, including when the static value is unresolved. Dynamic values, incomplete parent coverage, and unpaired variants remain unknown. Reports JSON Pointer changes without executing JavaScript; runtime behavior requires a separate agent-run probe.",
         kind: "application",
         inputSchema: compareJavaScriptExportShapesRequestSchema,
         outputSchema: exportShapeComparisonOutputSchema,
         examples: [
             {
-                title: "Compare one exact parser export without execution",
+                title: "Report observed return-property presence when static values stay unknown",
                 input: JAVASCRIPT_EXPORT_SHAPE_COMPARISON_EXAMPLE,
             },
             {

package/dist/contracts/artifactComparisonExample.js

@@ -8,13 +8,11 @@ const inventory = (digit) => {
     const nodes = [
         {
             artifact_id: artifactId,
-            kind: "resource",
             format: "file",
             sha256: sha,
             size: 1,
             media_type: null,
             architecture: null,
-            executable: false,
             content_state: "materialized",
             limitations: [],
         },
@@ -26,6 +24,8 @@ const inventory = (digit) => {
             parent_occurrence_id: null,
             logical_path: ".",
             entry_kind: "file",
+            artifact_kind: "resource",
+            artifact_format: "file",
             declared_size: 1,
             compressed_size: null,
             executable: false,

package/dist/contracts/artifactToolContracts.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { artifactOutputSchemas } from "./toolOutputSchemas.js";
+import { artifactOutputSchemas } from "./toolOutputSchemaGroups.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";

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

@@ -27,11 +27,11 @@ export const enhancedInputSchemas = {
         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({}),

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,9 +19,9 @@ 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("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 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("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,

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/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";

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,
-};