rea-agents 6.3.0 → 6.5.0

package/dist/contracts/gdbToolContracts.js

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "./toolEffects.js";
+const sessionId = z.string().uuid();
+const gdbCommandResult = z.strictObject({
+    command: z.string(),
+    mi: z.string(),
+    records: z.array(z.string()),
+    console: z.string(),
+    target: z.string(),
+    log: z.string(),
+    process_exit_observed: z.boolean().optional(),
+    process_exit_code: z.number().int().nullable().optional(),
+    process_exit_signal: z.string().nullable().optional(),
+    output_truncated: z.boolean(),
+    output_invalid_utf8: z.literal(true).optional(),
+    completion_status: z.enum(["complete", "unknown"]),
+});
+/** Persistent GDB/MI session contracts hosted by the existing REA MCP server. */
+export const GDB_TOOL_CONTRACTS = [
+    {
+        name: "start_gdb_session",
+        ...toolContractMetadata("start_gdb_session"),
+        kind: "native-provider",
+        description: "Start a BYO GDB process in MI3 mode when available, suppress startup files, and disable auto-loading. Persistent GDB sessions are available only on Linux, where REA can verify live inferior output descriptors through /proc before detaching; macOS descriptor verification is not implemented, and Windows Job Object cleanup can terminate debugger inferiors. Optionally set inferior_tty to a caller-selected terminal for future inferior runs; REA verifies the setting through GDB/MI before the session becomes ready. The selected terminal must remain available after GDB exits. A live inferior can be detached during close only while this durable output sink remains verified. The session persists in this REA MCP server process and receives an explicit session ID.",
+        inputSchema: z.strictObject({
+            inferior_tty: z
+                .string()
+                .min(1)
+                .optional()
+                .describe("Caller-selected terminal path for future inferior runs. GDB must report the exact configured path before the session is ready."),
+        }),
+        outputSchema: z.strictObject({
+            session_id: sessionId,
+            mi_version: z.enum(["mi3", "mi2"]),
+        }),
+        examples: [{ title: "Start GDB", input: {} }],
+    },
+    {
+        name: "gdb_console",
+        ...toolContractMetadata("gdb_console"),
+        kind: "native-provider",
+        description: "Run one unrestricted GDB CLI command through MI interpreter-exec console and return raw MI, console, target, and log records inline with Evidence. A command timeout preserves collected records with completion_status unknown and stops the owned debugger session. Commands can execute shell, alter target state, access files, and use network. Closing the debugger never implies target termination. In a shared MCP server, this admitted command closes any active binary-analysis session; after its effects have settled, call open_binary before further analysis. Close an active Ghidra session explicitly first.",
+        inputSchema: z.strictObject({
+            session_id: sessionId,
+            command: z.string().min(1),
+        }),
+        outputSchema: evidenceResultOf(gdbCommandResult),
+        examples: [
+            {
+                title: "Inspect loaded symbols",
+                input: {
+                    session_id: "00000000-0000-4000-8000-000000000001",
+                    command: "info functions",
+                },
+            },
+        ],
+    },
+    {
+        name: "gdb_session_status",
+        ...toolContractMetadata("gdb_session_status"),
+        kind: "native-provider",
+        description: "Return the observed lifecycle state and bounded recent MI records and process diagnostics for one persistent REA GDB session; truncation and invalid-UTF-8 fields report discarded or lossy data.",
+        inputSchema: z.strictObject({ session_id: sessionId }),
+        outputSchema: z.strictObject({
+            session_id: sessionId,
+            mi_version: z.enum(["mi3", "mi2"]),
+            state: z.enum(["ready", "closed"]),
+            recent_mi_records: z.array(z.string()),
+            recent_mi_records_truncated: z.boolean(),
+            mi_invalid_utf8: z.boolean(),
+            stderr: z.string(),
+            stderr_observed_bytes: z.number().int().nonnegative(),
+            stderr_truncated: z.boolean(),
+            stderr_invalid_utf8: z.boolean(),
+            diagnostics_truncated: z.boolean(),
+            inferior_tty: z.string().nullable(),
+            inferior_tty_verified: z.boolean(),
+        }),
+        examples: [
+            {
+                title: "Check GDB session",
+                input: { session_id: "00000000-0000-4000-8000-000000000001" },
+            },
+        ],
+    },
+    {
+        name: "close_gdb_session",
+        ...toolContractMetadata("close_gdb_session"),
+        kind: "native-provider",
+        description: "Close the owned GDB process after verifying the inferior state. When one live thread group has a verified durable output TTY, REA automatically detaches it, which may resume target execution; otherwise close reports that a disposition is required. REA never kills attached or remote targets as part of debugger cleanup. In a shared MCP server, this admitted close retires any active binary-analysis session; after target effects have settled, call open_binary before further analysis. Close an active Ghidra session explicitly first.",
+        inputSchema: z.strictObject({ session_id: sessionId }),
+        outputSchema: z.strictObject({
+            target_state: z.enum(["none_observed", "unknown"]),
+        }),
+        examples: [
+            {
+                title: "Close GDB session",
+                input: { session_id: "00000000-0000-4000-8000-000000000001" },
+            },
+        ],
+    },
+];

package/dist/contracts/go/goToolContracts.js

@@ -0,0 +1,20 @@
+import { goBinarySchema, inspectGoBinaryInputSchema, } from "../../domain/go/goBinary.js";
+import { toolContractMetadata } from "../toolEffects.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+/** Static Go metadata is independent of active native-analysis providers and host toolchains. */
+export const GO_TOOL_CONTRACTS = [
+    {
+        name: "inspect_go_binary",
+        ...toolContractMetadata("inspect_go_binary"),
+        kind: "artifact-provider",
+        description: "Inspect embedded Go compiler version, main module, dependency/replacement versions and build settings in an explicit local ELF, PE or thin Mach-O image. Returns original artifact SHA-256, exact build-info source ranges, raw framed module bytes and unparsed module-text lines inline as observed Evidence. Supports inline and historical pointer encodings without installing Go, opening a disassembler, executing the target, writing temporary files or accessing the network. Missing metadata is reported as unknown, not proof that an image is not Go. Does not recover functions, source mappings, types or runtime behavior. Resource guards bound files to 256 MiB, aggregate embedded strings to 1 MiB, structural table decoding to 16 MiB and complete inline metadata to 8 MiB; malformed, unsupported and oversized inputs receive typed failures rather than partial success.",
+        inputSchema: inspectGoBinaryInputSchema,
+        outputSchema: evidenceResultOf(goBinarySchema),
+        examples: [
+            {
+                title: "Inspect embedded build provenance",
+                input: { path: "/artifacts/application" },
+            },
+        ],
+    },
+];

package/dist/contracts/hopperMemoryContracts.js

@@ -1,7 +1,22 @@
 import { z } from "zod";
 import { address, document } from "./toolContractHelpers.js";
+import { bytePatternFields, validateBytePattern, } from "../domain/native/bytePattern.js";
 /** Hopper memory and file-mapping contracts. */
 export const HOPPER_MEMORY_TOOL_DEFINITIONS = [
+    {
+        name: "search_bytes",
+        description: "Find masked byte signatures in initialized analyzed memory. Hex byte pairs and ?? wildcards are supported; an optional equal-length hex mask selects bits. Bounds are inclusive. Matches are ordered by provider address and never span blocks. Coverage describes this page; reuse the same query with next_cursor to continue. Uninitialized blocks are listed separately. Ghidra only; Hopper is unavailable.",
+        inputSchema: z
+            .strictObject({
+            ...bytePatternFields,
+            document,
+            start: address.optional(),
+            end: address.optional(),
+            limit: z.number().int().min(1).max(1000).default(100),
+            cursor: z.string().min(1).optional(),
+        })
+            .superRefine(validateBytePattern),
+    },
     {
         name: "read_bytes",
         description: "Read analyzed bytes from one provider-normalized virtual address. The hexadecimal payload reports the exact returned length; incomplete reads remain explicit and unsupported provider APIs return typed capability unavailability.",

package/dist/contracts/inputSchemaPresentation.js

@@ -1,5 +1,5 @@
 import { isDeepStrictEqual } from "node:util";
-const schemaMaps = new Set([
+export const schemaMaps = new Set([
     "$defs",
     "definitions",
     "properties",
@@ -7,8 +7,8 @@ const schemaMaps = new Set([
     "dependentSchemas",
     "dependencies",
 ]);
-const schemaArrays = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
-const schemaChildren = new Set([
+export const schemaArrays = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
+export const schemaChildren = new Set([
     "items",
     "additionalItems",
     "contains",
@@ -23,6 +23,8 @@ const schemaChildren = new Set([
 ]);
 const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const resolveReference = (root, reference) => {
+    if (reference === "#")
+        return root;
     if (!reference.startsWith("#/"))
         return undefined;
     let value = root;
@@ -56,15 +58,15 @@ const describeSchema = (schema, root, describeProperty) => {
                 key,
                 Object.fromEntries(Object.entries(value).map(([name, child]) => {
                     const described = describeSchema(child, root, describeProperty);
+                    if (key !== "properties" || !isObject(described))
+                        return [name, described];
+                    const description = referencedDescription(root, described) ??
+                        describeProperty(name);
                     return [
                         name,
-                        key === "properties" && isObject(described)
-                            ? {
-                                ...described,
-                                description: referencedDescription(root, described) ??
-                                    describeProperty(name),
-                            }
-                            : described,
+                        description === undefined
+                            ? described
+                            : { ...described, description },
                     ];
                 })),
             ];
@@ -137,11 +139,6 @@ const flattenRootObjectUnion = (root) => {
     const required = sharedRequiredProperties(branches);
     // A field unique to a group still needs that group's required partners.
     // Counting properties alone would let optional fields pad an incomplete pair.
-    const dependencies = Object.fromEntries([...variants.keys()].flatMap((name) => {
-        const owners = branches.filter((branch) => Object.hasOwn(branch.properties ?? {}, name));
-        const partners = sharedRequiredProperties(owners).filter((partner) => partner !== name && !required.includes(partner));
-        return partners.length > 0 ? [[name, partners]] : [];
-    }));
     const fewestRequired = Math.min(...branches.map((branch) => requiredProperties(branch).length));
     // Groups that differ only in property values add no caller guidance.
     const groups = [...new Set(branches.map(inputGroup))];
@@ -151,8 +148,9 @@ const flattenRootObjectUnion = (root) => {
             ? `Provide a complete input group: ${groups.join("; ")}.`
             : undefined,
     ].filter((text) => text !== undefined);
+    const { dependencies: _dependencies, dependentRequired: _dependentRequired, ...presentation } = rest;
     return {
-        ...rest,
+        ...presentation,
         type: "object",
         ...(description.length > 0 ? { description: description.join(" ") } : {}),
         properties: Object.fromEntries([...variants].map(([name, schemas]) => [
@@ -161,13 +159,6 @@ const flattenRootObjectUnion = (root) => {
         ])),
         ...(required.length > 0 ? { required } : {}),
         ...(fewestRequired > 0 ? { minProperties: fewestRequired } : {}),
-        ...(Object.keys(dependencies).length > 0
-            ? {
-                [root.$schema === "http://json-schema.org/draft-07/schema#"
-                    ? "dependencies"
-                    : "dependentRequired"]: dependencies,
-            }
-            : {}),
         ...(branches.every((branch) => branch.additionalProperties === false)
             ? { additionalProperties: false }
             : {}),
@@ -177,5 +168,81 @@ const flattenRootObjectUnion = (root) => {
 export const presentInputJsonSchema = (root, describeProperty) => {
     const flattened = flattenRootObjectUnion(root);
     const described = describeSchema(flattened, flattened, describeProperty);
-    return isObject(described) ? described : flattened;
+    if (!isObject(described))
+        return flattened;
+    const { dependencies: _dependencies, dependentRequired: _dependentRequired, ...presentation } = described;
+    const rootDependencies = isObject(described.dependentRequired)
+        ? described.dependentRequired
+        : isObject(described.dependencies)
+            ? described.dependencies
+            : undefined;
+    const dependencyGuidance = rootDependencies === undefined
+        ? []
+        : Object.entries(rootDependencies).flatMap(([property, partners]) => Array.isArray(partners) &&
+            partners.every((partner) => typeof partner === "string")
+            ? [
+                `When ${property} is provided, also provide ${partners.join(" and ")}.`,
+            ]
+            : []);
+    if (dependencyGuidance.length === 0)
+        return presentation;
+    const description = [
+        typeof presentation.description === "string"
+            ? presentation.description
+            : undefined,
+        ...dependencyGuidance,
+    ].filter((text) => text !== undefined);
+    return { ...presentation, description: description.join(" ") };
+};
+/**
+ * Clients that render advertised inputs into SDK declarations expand
+ * schema-local references with a shared per-input budget: Pi 1.1.0 code-mode
+ * allows 32 expansions and degrades every later reference to `unknown`
+ * (morluto/rea#1632), hiding the fields those references describe. The budget
+ * counts conservatively — every resolvable, non-cyclic reference occurrence
+ * in every schema position — so any reference-resolving client stays within
+ * its measured limit.
+ */
+export const advertisedReferenceExpansionBudget = 32;
+const definitionKeys = new Set(["$defs", "definitions"]);
+const countReferenceExpansions = (node, root, active, count) => {
+    if (Array.isArray(node)) {
+        node.forEach((child) => countReferenceExpansions(child, root, active, count));
+        return;
+    }
+    if (!isObject(node))
+        return;
+    if (typeof node.$ref === "string" && !active.has(node.$ref)) {
+        const target = resolveReference(root, node.$ref);
+        if (target !== undefined) {
+            count.value += 1;
+            countReferenceExpansions(target, root, new Set([...active, node.$ref]), count);
+            return;
+        }
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (definitionKeys.has(key))
+            continue;
+        if (schemaMaps.has(key) && isObject(value)) {
+            for (const child of Object.values(value))
+                countReferenceExpansions(child, root, active, count);
+        }
+        else if (schemaArrays.has(key) || schemaChildren.has(key)) {
+            countReferenceExpansions(value, root, active, count);
+        }
+    }
+};
+/** Conservative client expansion count over every schema position. */
+export const countLocalReferenceExpansions = (schema) => {
+    const count = { value: 0 };
+    countReferenceExpansions(schema, schema, new Set(), count);
+    return count.value;
 };
+/**
+ * Keep the shared-definition form of an advertised input while clients can
+ * still resolve it. Once rendering would exhaust the reference budget, fall
+ * back to the inline projection, which carries no shared definitions for the
+ * nonrecursive schemas this repository advertises, so every field renders
+ * with complete structure in every reference-resolving client.
+ */
+export const inputSchemaWithinReferenceExpansionBudget = (shared, inline, budget) => countLocalReferenceExpansions(shared) <= budget ? shared : inline();

package/dist/contracts/investigationExamples.js

@@ -20,6 +20,7 @@ export const FUNCTION_COMPARISON_EVIDENCE = createEvidence(undefined, {
     result: jsonValueSchema.parse(comparison),
     confidence: "derived",
     authority: "analyst-inference",
+    limitations: comparison.limitations,
     evidenceLinks: [
         FUNCTION_COMPARISON_EXAMPLE.left.evidence_id,
         FUNCTION_COMPARISON_EXAMPLE.right.evidence_id,

package/dist/contracts/javascript/electronToolContracts.js

@@ -1,13 +1,21 @@
 import { toolContractMetadata } from "../toolEffects.js";
+import { electronFuseOutputSchemas } from "../toolOutputSchemaGroups.js";
 import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+import { inspectElectronFusesInputSchema } from "../../domain/electron/electronFuses.js";
 import { electronPageInspectionSchema, electronTargetListSchema, inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../../domain/javascript/electronObservation.js";
 import { electronActiveObservationInputSchema, electronActiveObservationResultSchema, } from "../../domain/javascript/electronActiveObservation.js";
+import { javascriptApplicationSummaryViewResultSchema } from "../../domain/analysisView/analysisView.js";
+import { analysisDetailOutputSchemaOf, analysisDetailSchema, } from "../analysisDetail.js";
 import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
 import { javascriptRuntimeReconciliationResultSchema, reconcileJavaScriptRuntimeInputSchema, } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";
 import { JAVASCRIPT_RUNTIME_RECONCILIATION_EXAMPLE } from "./javascriptRuntimeReconciliationExample.js";
 const listOutputSchema = evidenceResultOf(electronTargetListSchema);
 const inspectionOutputSchema = evidenceResultOf(electronPageInspectionSchema);
-const applicationOutputSchema = evidenceResultOf(javascriptApplicationAnalysisResultSchema);
+/** Caller-selected delivery of a completed JavaScript application analysis. */
+export const analyzeJavaScriptApplicationRequestSchema = analyzeJavaScriptApplicationInputSchema.extend({
+    detail: analysisDetailSchema,
+});
+const applicationOutputSchema = analysisDetailOutputSchemaOf(javascriptApplicationAnalysisResultSchema, javascriptApplicationSummaryViewResultSchema);
 const reconciliationOutputSchema = evidenceResultOf(javascriptRuntimeReconciliationResultSchema);
 const endpoint = "http://127.0.0.1:9223";
 const activeExample = {
@@ -54,9 +62,9 @@ export const ELECTRON_TOOL_CONTRACTS = [
     {
         name: "analyze_javascript_application",
         ...toolContractMetadata("analyze_javascript_application"),
-        description: "Reconstruct one local ASAR or extracted JavaScript application as an inline application graph without executing it. Returns recovered graph nodes, edges, semantic relations, integrity contradictions, limitations, and coverage. Integrity mismatches fail by default; record-and-continue retains observed bytes as untrusted and marks graph coverage partial.",
+        description: "Reconstruct one local ASAR or extracted JavaScript application as an inline application graph without executing it. Returns recovered graph nodes, edges, semantic relations, integrity contradictions, limitations, and coverage. Select source_paths to acquire and analyze only exact inventoried file paths; the complete artifact inventory and identity remain intact, and unselected sources remain explicit unknowns. Dependencies are not implicitly analyzed. Select detail summary to retain the complete analysis Evidence in this session and receive only its summary view, then inspect selected modules or pages with inspect_analysis_view. Summary detail reduces delivery, whereas source_paths bounds source analysis. Integrity mismatches fail by default; record-and-continue retains observed bytes as untrusted and marks graph coverage partial.",
         kind: "electron-provider",
-        inputSchema: analyzeJavaScriptApplicationInputSchema,
+        inputSchema: analyzeJavaScriptApplicationRequestSchema,
         outputSchema: applicationOutputSchema,
         examples: [
             {
@@ -67,6 +75,21 @@ export const ELECTRON_TOOL_CONTRACTS = [
                     integrity_policy: "fail",
                 },
             },
+            {
+                title: "Analyze selected entry sources before unrelated vendor files",
+                input: {
+                    input_path: "/Applications/Example.app/Contents/Resources/app.asar",
+                    source_paths: ["package.json", "main.js", "preload.js"],
+                    detail: "summary",
+                },
+            },
+            {
+                title: "Retain the complete analysis and return its summary view",
+                input: {
+                    input_path: "/Applications/Example.app/Contents/Resources/app.asar",
+                    detail: "summary",
+                },
+            },
         ],
     },
     {
@@ -94,4 +117,18 @@ export const ELECTRON_TOOL_CONTRACTS = [
             { title: "Exercise an owned Electron application", input: activeExample },
         ],
     },
+    {
+        name: "inspect_electron_fuses",
+        ...toolContractMetadata("inspect_electron_fuses"),
+        kind: "artifact-provider",
+        description: "Inspect packaged Electron fuse bytes in one local macOS app bundle, Electron Framework binary, Windows PE executable, or Linux ELF executable. Returns the artifact digest, per-slice wire version, fuse index, version-1 name, state, and raw byte, plus derived implications for Inspector flags, ELECTRON_RUN_AS_NODE, embedded ASAR integrity, and app.asar-only loading. A missing sentinel is unknown fuse state. Reads artifact bytes only and does not modify the selected file or open a runtime target.",
+        inputSchema: inspectElectronFusesInputSchema,
+        outputSchema: electronFuseOutputSchemas.inspect_electron_fuses,
+        examples: [
+            {
+                title: "Read packaged Electron fuse state",
+                input: { path: "/Applications/Example.app" },
+            },
+        ],
+    },
 ];

package/dist/contracts/javascript/javascriptRecoveryToolContracts.js

@@ -7,7 +7,7 @@ export const JAVASCRIPT_RECOVERY_TOOL_CONTRACTS = [
         name: "recover_javascript_sources",
         ...toolContractMetadata("recover_javascript_sources"),
         kind: "application",
-        description: "Recover readable modules from one local UTF-8 JavaScript script/bundle into an absent directory, using caller-supplied Wakaru 1.13.0 on Linux x64. Returns original/derived digests, extraction byte ranges, emitted source maps, warnings and analysis_input inline. Structural splitting may fall back to one module; original names and runtime equivalence remain unknown. No application code execution. Requires util-linux prlimit; one worker, 1 GiB address-space ceiling, 120-second deadline, 64 MiB input, 128 MiB output, 10000 entries and 8 MiB per diagnostic/report stream.",
+        description: "Recover readable modules from local UTF-8 JavaScript scripts/bundles into an absent directory, using caller-supplied Wakaru ^1.13.0 (verified with 1.14.0) on Linux x64. Use additional_paths for related chunks; each input retains its own snapshot and provenance. Returns original/derived digests, extraction byte ranges, emitted source maps, warnings and analysis_input inline. Structural splitting may fall back to one module; original names and runtime equivalence remain unknown. No application code execution. Requires util-linux prlimit; one worker, 1 GiB address-space ceiling, 120-second deadline, 64 MiB total input, 128 MiB output, 10000 entries and 8 MiB per diagnostic/report stream.",
         inputSchema: javascriptRecoveryInputSchema,
         outputSchema: evidenceResultOf(javascriptRecoveryResultSchema),
         examples: [
@@ -18,6 +18,18 @@ export const JAVASCRIPT_RECOVERY_TOOL_CONTRACTS = [
                     output_directory: "/tmp/recovered-app",
                 },
             },
+            {
+                title: "Recover a code-split bundle together",
+                input: {
+                    path: "/tmp/web-scripts/main.js",
+                    additional_paths: [
+                        "/tmp/web-scripts/runtime.js",
+                        "/tmp/web-scripts/shared.js",
+                        "/tmp/web-scripts/checkout.chunk.js",
+                    ],
+                    output_directory: "/tmp/recovered-chunks",
+                },
+            },
         ],
     },
 ];

package/dist/contracts/jeb/jebToolContracts.js

@@ -0,0 +1,64 @@
+import { jebInputSchemas, jebResultSchemas, } from "../../domain/jeb/jebAnalysis.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "../toolEffects.js";
+/** JEB-backed inspection served by a caller-supplied running engine client. */
+export const JEB_TOOL_CONTRACTS = [
+    {
+        name: "inspect_jeb_client",
+        ...toolContractMetadata("inspect_jeb_client"),
+        description: "Inspect the running JEB client serving MCP: engine version, GUI or headless mode, and startup time. Does not open a target. Requires a caller-started JEB client reachable at REA_JEB_MCP_URL (default http://127.0.0.1:8425/mcp); REA never installs or launches JEB.",
+        kind: "jeb-provider",
+        inputSchema: jebInputSchemas.inspect_jeb_client,
+        outputSchema: evidenceResultOf(jebResultSchemas.inspect_jeb_client),
+        examples: [{ title: "Check the engine", input: {} }],
+    },
+    {
+        name: "open_jeb_project",
+        ...toolContractMetadata("open_jeb_project"),
+        description: "Open or create a JEB project from an artifact file or existing .jdb2 database on the engine host. Returns the project's input-file digests and top-level units. The engine analyzes the target itself; REA does not read the file or execute it. Fails when a project is already open.",
+        kind: "jeb-provider",
+        inputSchema: jebInputSchemas.open_jeb_project,
+        outputSchema: evidenceResultOf(jebResultSchemas.open_jeb_project),
+        examples: [
+            {
+                title: "Open a target for analysis",
+                input: { path: "/tmp/Example.apk" },
+            },
+        ],
+    },
+    {
+        name: "list_jeb_units",
+        ...toolContractMetadata("list_jeb_units"),
+        description: "List project units by stable unit path and type, with optional wildcard filter, parent restriction, and pagination. The engine caps pages at 100 units; a full page reports partial coverage because more units may exist. Read-only.",
+        kind: "jeb-provider",
+        inputSchema: jebInputSchemas.list_jeb_units,
+        outputSchema: evidenceResultOf(jebResultSchemas.list_jeb_units),
+        examples: [
+            {
+                title: "List units",
+                input: {},
+            },
+            {
+                title: "Find DEX units",
+                input: { filter: "*.dex" },
+            },
+        ],
+    },
+    {
+        name: "decompile_jeb_item",
+        ...toolContractMetadata("decompile_jeb_item"),
+        description: "Decompile one type or method to engine pseudo-code using its decompiler (Dalvik, Java, or native). item_address comes from the engine's code item listing; unit_path defaults to the engine's first code unit and stays unknown when omitted. Read-only with respect to the target file.",
+        kind: "jeb-provider",
+        inputSchema: jebInputSchemas.decompile_jeb_item,
+        outputSchema: evidenceResultOf(jebResultSchemas.decompile_jeb_item),
+        examples: [
+            {
+                title: "Decompile a method",
+                input: {
+                    item_address: "Lcom/example/Main;->onCreate()V",
+                    item_kind: "method",
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/managed/managedToolContracts.js

@@ -4,6 +4,7 @@ import { managedOutputSchemas } from "../toolOutputSchemaGroups.js";
 import { toolContractMetadata } from "../toolEffects.js";
 import { requireOutputSchema } from "../toolOutputSchemaPrimitives.js";
 import { localPathStringSchema } from "../../domain/localPath.js";
+import { analysisDetailSchema } from "../analysisDetail.js";
 /** Exact caller boundary for execution-free PE/CLI triage and identity. */
 export const managedTargetInputSchema = z.strictObject({
     path: localPathStringSchema
@@ -13,6 +14,25 @@ export const managedTargetInputSchema = z.strictObject({
         .describe("Explicit absolute managed PE/CLI path; omit to reuse the previously selected managed target")
         .optional(),
 });
+/** Delivery selection belongs to artifact and member inspection, not native queries. */
+export const managedArtifactInputSchema = managedTargetInputSchema.extend({
+    detail: analysisDetailSchema.unwrap().optional(),
+});
+/** Member inspection may select declaring types before members are decoded. */
+export const managedMembersInputSchema = managedArtifactInputSchema.extend({
+    type_names: z
+        .array(z
+        .string()
+        .min(1)
+        .describe("Exact declaring-type full_name: namespace-qualified for top-level types (System.Threading.Monitor); nested types report their bare name, so it selects every nested type of that name"))
+        .min(1)
+        .refine((names) => new Set(names).size === names.length, {
+        message: "type_names must not repeat a name",
+    })
+        .meta({ uniqueItems: true })
+        .describe("Inspect only the fields, methods, call edges, and field accesses declared by these exact type full names, and the user strings their method bodies load; omit to inspect every type. Unmatched names are reported in selection.unmatched_type_names.")
+        .optional(),
+});
 const outputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_artifact");
 const memberOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_members");
 const nativeBoundaryOutputSchema = requireOutputSchema(managedOutputSchemas, "inspect_managed_native_boundaries");
@@ -21,29 +41,48 @@ export const MANAGED_TOOL_CONTRACTS = [
     {
         name: "inspect_managed_artifact",
         ...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.",
+        description: 'Inspect an explicit PE/CLI path, or the selected managed target, without loading or executing target code. Omitted or complete detail returns complete metadata inventories with original coverage. Select detail: "summary" on the first call for complete identity, PE/CLI, classification with its evidence, module/MVID, assembly, frameworks, returned-collection counts, coverage/issues and limitations. It retains complete Evidence and returns a distinct linked inspect_analysis_view summary. Page original references/resources/attributes with view kind managed and normalized_result.parent_evidence_id. Counts cover producer-returned rows; partial, unavailable or malformed metadata remains explicit and tokens remain build-local.',
         kind: "managed-provider",
-        inputSchema: managedTargetInputSchema,
+        inputSchema: managedArtifactInputSchema,
         outputSchema,
         examples: [
             {
                 title: "Example inspect managed artifact request",
                 input: { path: "/tmp/Example.dll" },
             },
+            {
+                title: "Inspect identity and coverage without unrelated metadata inventories",
+                input: { path: "/tmp/Example.dll", detail: "summary" },
+            },
         ],
     },
     {
         name: "inspect_managed_members",
         ...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.",
+        description: 'Inspect PE/CLI metadata members, signatures, raw CIL hashes, decoded-instruction-tuple hashes, separately reported exception regions, call edges, field-access anchors, and the #US string literals that ldstr loads, without loading or executing target code. Select type_names to decode only the members of those exact declaring types and the literals their bodies load, which keeps large assemblies such as a base class library within the representation budget. 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. Omitted or complete detail returns every collection, including the assembly-wide member_refs and exported_types, which type_names does not narrow. Select detail: "summary" for identity, metadata status, selection with unmatched names, coverage/issues, limitations and per-collection counts; it retains complete Evidence and returns a linked inspect_analysis_view summary. Page original rows with view kind managed-members, normalized_result.parent_evidence_id and collection types/exported_types/fields/methods/member_refs/call_edges/field_accesses/user_strings.',
         kind: "managed-provider",
-        inputSchema: managedTargetInputSchema,
+        inputSchema: managedMembersInputSchema,
         outputSchema: memberOutputSchema,
         examples: [
             {
                 title: "Example inspect managed members request",
                 input: {},
             },
+            {
+                title: "Example inspect selected managed types request",
+                input: {
+                    path: "/tmp/mscorlib.dll",
+                    type_names: ["System.Threading.Monitor"],
+                },
+            },
+            {
+                title: "Summarize selected managed types and retain their members",
+                input: {
+                    path: "/tmp/mscorlib.dll",
+                    type_names: ["System.Threading.Monitor"],
+                    detail: "summary",
+                },
+            },
         ],
     },
     {

package/dist/contracts/managed/managedWorkflowExamples.js

@@ -36,11 +36,14 @@ const emptyManagedMembers = (sha256, mvid) => ({
         requires_mvid: mvid,
     },
     types: [],
+    exported_types: [],
     fields: [],
     methods: [],
     member_refs: [],
     call_edges: [],
     field_accesses: [],
+    user_strings: { state: "complete", literals: [], issues: [] },
+    selection: null,
     coverage: { state: "complete", issues: [] },
     limitations: [],
 });
@@ -197,6 +200,7 @@ const boundaryEvidence = () => {
 const nativeExportEvidence = () => {
     const result = {
         format: "mach-o",
+        selected_architecture: { name: "x86_64", container_file_offset: null },
         endian: "little",
         word_size: 64,
         file_type: "dylib",
@@ -219,7 +223,9 @@ const nativeExportEvidence = () => {
         ]),
         segments: coverage([]),
         provenance: [],
-        limitations: [],
+        limitations: [
+            "Selected Mach-O slice container offset is unknown in this synthetic example.",
+        ],
     };
     return createEvidence({
         path: "/examples/nativehelper.dll",