rea-agents 6.4.0 → 6.7.0

package/dist/contracts/android/androidToolContracts.js

@@ -1,4 +1,6 @@
-import { androidInputSchemas, androidResultSchemas, } from "../../domain/android/androidAnalysis.js";
+import { z } from "zod";
+import { androidInputSchemas, androidPackageInspectionInputSchema, androidResultSchemas, } from "../../domain/android/androidAnalysis.js";
+import { androidPackageSummaryViewResultSchema } from "../../domain/analysisView/analysisView.js";
 import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
 import { toolContractMetadata } from "../toolEffects.js";
 /** Static APK operations backed by a separately supplied headless engine. */
@@ -6,18 +8,25 @@ export const ANDROID_TOOL_CONTRACTS = [
     {
         name: "inspect_android_package",
         ...toolContractMetadata("inspect_android_package"),
-        description: "Inspect a local APK's package, SDK and permission declarations, decoded manifest and class/resource counts. Does not execute the APK or verify signatures. Requires a caller-supplied JADX MCP JAR and JDK; uses one worker in an isolated temporary workspace.",
+        description: 'Inspect a local APK\'s package, SDK and permission declarations, decoded manifest and class/resource counts. Omitted or complete detail preserves the complete result. Select detail: "summary" for all declarations, engine identity and counts without decoded manifest text or duplicate raw calls; retains the complete source and returns a distinct linked inspect_analysis_view summary. Read the exact retained manifest with view kind android, facet manifest, offset and limit (UTF-16 code units), using normalized_result.parent_evidence_id. Does not execute the APK or verify signatures. Requires a caller-supplied JADX MCP JAR and JDK; uses one worker in an isolated temporary workspace.',
         kind: "android-provider",
-        inputSchema: androidInputSchemas.inspect_android_package,
-        outputSchema: evidenceResultOf(androidResultSchemas.inspect_android_package),
+        inputSchema: androidPackageInspectionInputSchema,
+        outputSchema: evidenceResultOf(z.union([
+            androidResultSchemas.inspect_android_package,
+            androidPackageSummaryViewResultSchema,
+        ])),
         examples: [
             { title: "Inspect an APK", input: { path: "/tmp/Example.apk" } },
+            {
+                title: "Inspect APK declarations with retained manifest",
+                input: { path: "/tmp/Example.apk", detail: "summary" },
+            },
         ],
     },
     {
         name: "search_android_classes",
         ...toolContractMetadata("search_android_classes"),
-        description: "Search complete decompiler class names in an explicit local APK by case-sensitive substring. Empty query inventories all classes. Retains artifact and engine identity; no APK execution.",
+        description: "Search complete top-level decompiler class-name rows in an explicit local APK by case-sensitive substring. Empty query inventories all rows. Repeated names remain repeated and appear in duplicate_names; the provider accepts only class names for lookup, so these rows do not identify which same-name class node a later lookup selects. Retains artifact and engine identity; no APK execution.",
         kind: "android-provider",
         inputSchema: androidInputSchemas.search_android_classes,
         outputSchema: evidenceResultOf(androidResultSchemas.search_android_classes),
@@ -31,7 +40,7 @@ export const ANDROID_TOOL_CONTRACTS = [
     {
         name: "inspect_android_class",
         ...toolContractMetadata("inspect_android_class"),
-        description: "Inspect one exact Android class's parsed methods, fields and inner classes, including synthetic members. Returns display signatures and explicit unknown DEX descriptors without generating source. Overload indices remain consistent within the artifact and engine session.",
+        description: "Inspect one exact Android class's parsed methods, fields and inner classes, including synthetic members. Returns display signatures and exact DEX prototypes without generating source. A prototype is not a complete raw method ID; overload indices remain consistent within the artifact and engine session.",
         kind: "android-provider",
         inputSchema: androidInputSchemas.inspect_android_class,
         outputSchema: evidenceResultOf(androidResultSchemas.inspect_android_class),
@@ -45,7 +54,7 @@ export const ANDROID_TOOL_CONTRACTS = [
     {
         name: "inspect_android_method",
         ...toolContractMetadata("inspect_android_method"),
-        description: "Decompile one Android method with smali fallback. Requires explicit overload_index when multiple methods share a name. Reports representation, fallback markers and source truncation; never treats display signatures as exact DEX identities.",
+        description: "Decompile one Android method with smali fallback. Requires explicit overload_index when multiple methods share a name. Reports its DEX prototype, representation, fallback markers and source truncation; display signatures may be aliases.",
         kind: "android-provider",
         inputSchema: androidInputSchemas.inspect_android_method,
         outputSchema: evidenceResultOf(androidResultSchemas.inspect_android_method),
@@ -63,7 +72,7 @@ export const ANDROID_TOOL_CONTRACTS = [
     {
         name: "trace_android_references",
         ...toolContractMetadata("trace_android_references"),
-        description: "Trace incoming static references to an exact Android class or unique method. Overloaded method reference queries are explicitly unsupported by the current engine. Source lines and DEX offsets remain unknown; no runtime calls are inferred.",
+        description: "Trace incoming static using nodes to an exact Android class or selected method overload. The total counts containing nodes, not individual invoke instructions. Use inspect_android_class to choose an overload_index when names collide. Source lines and the containing node dex_offset remain unknown. direct_invokes carries exact DEX code-unit instruction offsets when available; direct_invokes_exhaustive false marks byte-bounded partial instruction evidence, and null means coverage is unknown. Using-node coverage remains separate; no runtime calls are inferred.",
         kind: "android-provider",
         inputSchema: androidInputSchemas.trace_android_references,
         outputSchema: evidenceResultOf(androidResultSchemas.trace_android_references),

package/dist/contracts/apktool/apktoolToolContracts.js

@@ -15,7 +15,7 @@ export const APKTOOL_TOOL_CONTRACTS = [
     {
         name: "decode_android_resources",
         ...toolContractMetadata("decode_android_resources"),
-        description: "Decode one local APK's resources with `apktool d --no-src` in a provider-owned workspace that is removed after projection: the readable AndroidManifest.xml, apktool.yml version and SDK facts, the app's string resources (default or one locale, bounded to 2000 entries), available string locales, and the decoded file count. The target APK is digest with SHA-256 before decoding; smali is skipped because Java-source recovery belongs to the JADX family.",
+        description: "Decode one local APK's resources with `apktool d --no-src` in a provider-owned workspace that is removed after projection: the readable AndroidManifest.xml, apktool.yml version and SDK facts, the app's string resources (default or selected locales, bounded to 2000 entries per table), selectable string locales, and the decoded file count. The target APK is digest with SHA-256 before decoding; smali is skipped because Java-source recovery belongs to the JADX family.",
         kind: "apktool-provider",
         inputSchema: apktoolInputSchemas.decode_android_resources,
         outputSchema: evidenceResultOf(apktoolResultSchemas.decode_android_resources),
@@ -28,6 +28,10 @@ export const APKTOOL_TOOL_CONTRACTS = [
                 title: "Decode one locale's strings",
                 input: { path: "/targets/Example.apk", locale: "de" },
             },
+            {
+                title: "Decode multiple locale string tables in one pass",
+                input: { path: "/targets/Example.apk", locales: ["de", "fr"] },
+            },
         ],
     },
 ];

package/dist/contracts/applicationToolContracts.js

@@ -9,11 +9,12 @@ import { reconstructionClosureResultSchema } from "../domain/reconstructionCover
 import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
 import { androidApplicationProjectionInputSchema, androidApplicationProjectionResultSchema, } from "../domain/android/androidApplication.js";
 import { appleApplicationProjectionInputSchema, appleApplicationProjectionResultSchema, } from "../domain/apple/appleApplication.js";
+import { harmonyApplicationProjectionInputSchema, harmonyApplicationProjectionResultSchema, } from "../domain/harmony/harmonyApplication.js";
 import { toolContractMetadata } from "./toolEffects.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";
+import { ANDROID_APPLICATION_GRAPH_EXAMPLE, APPLE_APPLICATION_GRAPH_EXAMPLE, HARMONY_APPLICATION_GRAPH_EXAMPLE, MACOS_APPLICATION_GRAPH_EXAMPLE, } from "./mobileApplicationGraphExamples.js";
 const traceOutputSchema = evidenceResultOf(applicationFeatureTraceResultSchema);
 const semanticTraceOutputSchema = evidenceResultOf(javaScriptSemanticTraceResultSchema);
 const comparisonOutputSchema = evidenceResultOf(applicationVersionComparisonResultSchema);
@@ -158,7 +159,7 @@ export const APPLICATION_TOOL_CONTRACTS = [
     {
         name: "evaluate_reconstruction_coverage",
         ...toolContractMetadata("evaluate_reconstruction_coverage"),
-        description: "Evaluate inline evidence-backed reconstruction coverage against one named boundary. Missing ownership or inventory is partial; stale, weak, truncated, skipped, or unresolved proof is unknown; contradictions, failed proof, missing owners, and authority routing fail closed.",
+        description: "Evaluate inline evidence-backed reconstruction coverage against one named boundary. Missing ownership or inventory is partial; stale, weak, truncated, skipped, unresolved, or conflicting tied verifier proof is unknown; contradictions, failed proof, missing owners, and authority routing fail closed.",
         kind: "application",
         inputSchema: reconstructionCoverageEvaluationInputSchema,
         outputSchema: reconstructionClosureResultSchema,
@@ -237,6 +238,20 @@ export const APPLICATION_TOOL_CONTRACTS = [
             },
         ],
     },
+    {
+        name: "project_harmony_application_graph",
+        ...toolContractMetadata("project_harmony_application_graph"),
+        description: "Project authenticated HarmonyOS HAP, HSP, or App Pack inventory Evidence into an execution-free application inventory. Reports packaging-model hints (Stage module.json versus FA config.json), exact component paths and hashes (manifests, Ark bytecode, resources, native libraries, JavaScript, signing), App Pack child packages, runtime-family hints, and path-based N-API bridge hypotheses without decoding Ark bytecode, parsing manifest semantics, or claiming observed runtime calls.",
+        kind: "application",
+        inputSchema: harmonyApplicationProjectionInputSchema,
+        outputSchema: evidenceResultOf(harmonyApplicationProjectionResultSchema),
+        examples: [
+            {
+                title: "Project HAP inventory Evidence into a HarmonyOS application graph",
+                input: HARMONY_APPLICATION_GRAPH_EXAMPLE,
+            },
+        ],
+    },
 ];
 export function applicationToolContract(name) {
     const contract = APPLICATION_TOOL_CONTRACTS.find(({ name: candidate }) => candidate === name);

package/dist/contracts/artifactComparisonExample.js

@@ -1,10 +1,9 @@
-import { digestCanonicalValue } from "../domain/canonicalDigest.js";
+import { artifactGraphDigest, artifactIdForContent, artifactManifestId, occurrenceIdForLocation, } from "../domain/artifactIdentity.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 const inventory = (digit) => {
     const sha = digit.repeat(64);
-    const artifactId = `art_${digestCanonicalValue({ sha256: sha }, "Artifact example")}`;
-    const occurrenceId = `occ_${digestCanonicalValue({ root: artifactId }, "Artifact example")}`;
+    const artifactId = artifactIdForContent(sha);
     const nodes = [
         {
             artifact_id: artifactId,
@@ -19,7 +18,11 @@ const inventory = (digit) => {
     ];
     const occurrences = [
         {
-            occurrence_id: occurrenceId,
+            occurrence_id: occurrenceIdForLocation({
+                rootArtifactId: artifactId,
+                logicalPath: ".",
+                entryKind: "file",
+            }),
             artifact_id: artifactId,
             parent_occurrence_id: null,
             logical_path: ".",
@@ -35,30 +38,31 @@ const inventory = (digit) => {
             limitations: [],
         },
     ];
-    const graphSha256 = digestCanonicalValue({
+    const edges = [];
+    const integrityContradictions = [];
+    const graphSha256 = artifactGraphDigest({
         nodes,
         occurrences,
-        edges: [],
-        integrity_contradictions: [],
-    }, "Artifact example");
+        edges,
+        contradictions: integrityContradictions,
+    });
     return jsonValueSchema.parse({
         manifest: {
-            manifest_id: `agm_${digestCanonicalValue({
-                root_artifact_id: artifactId,
-                graph_sha256: graphSha256,
-            }, "Artifact example")}`,
+            manifest_id: artifactManifestId(artifactId, graphSha256),
             root_artifact_id: artifactId,
             root_sha256: sha,
             root_format: "file",
             graph_sha256: graphSha256,
             node_count: nodes.length,
             occurrence_count: occurrences.length,
-            edge_count: 0,
+            edge_count: edges.length,
         },
         nodes,
         occurrences,
-        edges: [],
+        edges,
         provenance: [],
+        integrity_contradictions: integrityContradictions,
+        coverage: { scope: "root", status: "complete" },
         limitations: [],
     });
 };

package/dist/contracts/artifactToolContracts.js

@@ -7,17 +7,26 @@ import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 import { appleAssetCatalogInputSchema } from "../domain/apple/appleAssetCatalog.js";
 import { dylibResolutionInputSchema } from "../domain/apple/dylibResolution.js";
 import { keyedArchiveInputSchema } from "../domain/apple/keyedArchive.js";
+import { localPathStringSchema } from "../domain/localPath.js";
+import { analysisDetailSchema } from "./analysisDetail.js";
 /** Exact caller boundary for deterministic artifact inventory. */
 export const artifactInventoryInputSchema = z.strictObject({
     integrity_policy: artifactIntegrityPolicySchema,
 });
+/** Delivery selection belongs to the adapter, not the inventory producer. */
+export const artifactInspectionInputSchema = artifactInventoryInputSchema.extend({
+    detail: analysisDetailSchema
+        .unwrap()
+        .optional()
+        .describe("Omitted or complete returns the complete inspection Evidence. summary retains that complete Evidence in this session and returns its inspect_analysis_view summary; use normalized_result.parent_evidence_id for inventory views."),
+});
 /** Extraction needs no selector: it materializes every regular child file. */
 export const artifactExtractionInputSchema = z.strictObject({
     integrity_policy: artifactIntegrityPolicySchema,
 });
 /** Provider input containing the destination chosen by the local adapter. */
 export const artifactExtractionExecutionSchema = artifactExtractionInputSchema.extend({
-    output_root: z.string().min(1),
+    output_root: localPathStringSchema,
 });
 const exampleInputSchema = z.record(z.string(), jsonValueSchema);
 const examples = {
@@ -50,12 +59,16 @@ const artifact = (name, description, inputSchema) => {
 };
 /** Artifact-graph inventory and safe extraction contracts. */
 export const ARTIFACT_TOOL_CONTRACTS = [
-    artifact("inspect_artifact", "Inspect an active archive or application package in one call. Returns the complete content-addressed artifact graph once, as the nested inventory Evidence, with root and integrity observations, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInventoryInputSchema),
+    artifact("inspect_artifact", "Inspect an active archive or application package in one call. By default returns the complete content-addressed artifact graph once, as the typed nested inventory Evidence, with root and integrity observations, integrity contradictions, hypotheses, unexplored branches, limitations, and next probes inline. Optional detail summary retains the complete inspection and returns its derived summary view; read exact paths or inventory pages with inspect_analysis_view using parent_evidence_id. This changes delivery, not inventory coverage. Read-only DMG mounting is used automatically on supported macOS hosts. Integrity mismatches fail by default; record-and-continue keeps mismatches explicitly untrusted. It does not extract files; use extract_artifact to materialize its regular contents.", artifactInspectionInputSchema),
     artifact("extract_artifact", "Extract all regular files from the active archive or application package into a fresh temporary directory chosen by REA. The result includes its location. Rejects traversal and symlink escapes, never overwrites, and verifies cleanup. Integrity mismatches fail by default; record-and-continue extracts the observed bytes and returns each mismatch as an explicitly untrusted integrity contradiction.", artifactExtractionInputSchema),
-    artifact("decode_interface_builder", "Decode compiled storyboard and nib archives inside the active Apple app bundle, including keyed property lists and NIBArchive object tables, into a bounded object, hierarchy, and connection graph. This is static archive parsing; unrecognized archive classes and unresolved code handlers remain explicit unknowns.", z.strictObject({
+    artifact("decode_interface_builder", "Decode compiled storyboard and nib archives inside the active Apple app bundle, including keyed property lists and NIBArchive object tables, into a bounded object, hierarchy, and connection graph. This is static archive parsing; unrecognized archive classes and unresolved code handlers remain explicit unknowns. A full app graph is often several megabytes; detail summary retains it and returns documents with node, edge and coverage counts, then page rows, optionally one document's, with inspect_analysis_view kind interface-builder.", z.strictObject({
         max_documents: z.number().int().min(1).max(64).default(64),
         max_objects: z.number().int().min(1).max(20_000).default(20_000),
         max_connections: z.number().int().min(1).max(40_000).default(40_000),
+        detail: analysisDetailSchema
+            .unwrap()
+            .optional()
+            .describe("Omitted or complete returns the complete decoded graph Evidence. summary retains that complete Evidence in this session and returns its inspect_analysis_view summary; use normalized_result.parent_evidence_id for interface-builder pages."),
     })),
     artifact("inspect_keyed_archive", "Inspect one Foundation NSKeyedArchiver plist in the active app bundle as original object-table nodes, class descriptors, named roots, and UID edges. Preserves shared and cyclic references without instantiating classes. The path is relative to the bundle; root selection and object pagination preserve original identities.", keyedArchiveInputSchema),
     artifact("inspect_asset_catalog", "Inspect compiled Assets.car metadata in an active Apple app bundle. Returns stable paginated catalog and rendition records with raw assetutil metadata and catalog digests; rendition bytes are not extracted.", appleAssetCatalogInputSchema),

package/dist/contracts/browserScenarioToolContracts.js

@@ -21,7 +21,7 @@ export const BROWSER_SCENARIO_TOOL_CONTRACTS = [
     {
         name: "capture_browser_scenario",
         ...toolContractMetadata("capture_browser_scenario"),
-        description: "Run a controlled browser scenario when passive observation cannot exercise the application. Launch the selected executable or connect to a loopback CDP target, provide a start URL and actions, and select storage or artifacts when needed. Environment, empty storage, and a URL-only final capture are defaults. capture.network selects request_body, response_body, and header_values independently; selected content is returned inline with transaction and event references, byte digests, and explicit unavailable states. Credentials and declared secrets are redacted. Agents can run their own local fixture servers to control application responses. Actions run until completion or cancellation unless timeout_ms is set. Results are returned inline.",
+        description: "Run a controlled browser scenario when passive observation cannot exercise the application. Launch the selected executable or connect to a loopback CDP target, provide a start URL and actions, and select storage or artifacts when needed. Environment, empty storage, a URL-only final capture, and measured event-retention budgets are defaults. capture.network selects request_body, response_body, and header_values independently; capture.limits lets callers raise or lower the event count, retained-allocation estimates, network transaction count, and network content budgets. Selected content is returned inline with transaction and event references, byte digests, and explicit unavailable states. Budget omissions identify affected event kinds and network transactions. Credentials and declared secrets are redacted. Agents can run their own local fixture servers to control application responses. Actions run until completion or cancellation unless timeout_ms is set. Results are returned inline.",
         kind: "browser-provider",
         inputSchema: browserScenarioInputSchema,
         outputSchema: evidenceResultOf(browserScenarioCaptureSchema),

package/dist/contracts/browserToolContracts.js

@@ -4,6 +4,7 @@ import { analyzeWebBundleInputSchema, webBundleAnalysisSchema, } from "../domain
 import { observeWebSessionInputSchema, webObservationSessionSchema, } from "../domain/browserSession.js";
 import { discoverWebMcpToolsInputSchema, webMcpDiscoverySchema, } from "../domain/webMcpDiscovery.js";
 import { browserCaptureComparisonInputSchema, browserCaptureComparisonSchema, } from "../domain/browserCaptureComparison.js";
+import { DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS } from "../domain/browserScenarioCaptureLimits.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, webScreenshotDiffSchema, webScreenshotSchema, } from "../domain/webScreenshot.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
@@ -54,6 +55,8 @@ const exampleScenarioCapture = () => ({
             response_body: false,
             header_values: false,
         },
+        event_families: [],
+        limits: DEFAULT_BROWSER_SCENARIO_CAPTURE_LIMITS,
     },
     duration_ms: 10,
     steps: [
@@ -86,7 +89,16 @@ const exampleScenarioCapture = () => ({
             completeness: scenarioCompleteness,
         },
     ],
-    events: { retained: 0, dropped: 0, items: [] },
+    events: {
+        retained: 0,
+        dropped: 0,
+        items: [],
+        omissions: {
+            by_kind: [],
+            network_transactions: [],
+            network_transaction_range: null,
+        },
+    },
     completeness: scenarioCompleteness,
     limitations: [],
 });

package/dist/contracts/captures/captureToolContracts.js

@@ -0,0 +1,42 @@
+import { inspectPacketFieldsInputSchema, packetFieldsCatalogSchema, } from "../../domain/captures/packetFields.js";
+import { inspectPacketCaptureInputSchema, packetCaptureSchema, } from "../../domain/captures/packetCapture.js";
+import { toolContractMetadata } from "../toolEffects.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+export const CAPTURE_TOOL_CONTRACTS = [
+    {
+        name: "inspect_packet_fields",
+        ...toolContractMetadata("inspect_packet_fields"),
+        kind: "artifact-provider",
+        description: "Discover protocols or field names/types registered in the installed TShark 4.x. kind defaults to protocols; use fields and optional exact protocol abbreviation to select field definitions. query searches name/abbreviation/description by case-insensitive literal substring. Return 50 matches by default with offset/limit paging; null requests all remaining within resource limits. Preserve type/base/bitmask/description, duplicate registrations, source line numbers, coverage, tool identity and diagnostics. Linux, REA_TSHARK_COMMAND and prlimit required. No capture file, interface or binary target needed. Registrations describe tool capabilities, not observed traffic. Each call rereads the glossary; use selected fields with inspect_packet_capture.",
+        inputSchema: inspectPacketFieldsInputSchema,
+        outputSchema: evidenceResultOf(packetFieldsCatalogSchema),
+        examples: [
+            { title: "Find USB protocol registrations", input: { query: "usb" } },
+            {
+                title: "Find the installed USB vendor-ID field",
+                input: { kind: "fields", protocol: "usb", query: "idVendor" },
+            },
+        ],
+    },
+    {
+        name: "inspect_packet_capture",
+        ...toolContractMetadata("inspect_packet_capture"),
+        kind: "artifact-provider",
+        description: "Inspect caller-selected fields in an existing local packet capture with TShark 4.x. Return 50 matching frames by default, with match_offset/match_limit paging and coverage counts; match_limit:null requests all remaining matches. Preserve repeated values, frame numbers, display filter, decode-as rules and pass mode in inline Evidence with source/tool identity and diagnostics. Optional packet_limit counts input packets before filtering; output paging does not shorten dissection or two-pass reassembly. Requires Linux, util-linux prlimit, and absolute REA_TSHARK_COMMAND. File-only analysis; no live capture or device communication. Missing fields or no matches do not establish absence of device traffic.",
+        inputSchema: inspectPacketCaptureInputSchema,
+        outputSchema: evidenceResultOf(packetCaptureSchema),
+        examples: [
+            {
+                title: "Inspect UDP exchanges in a recording",
+                input: {
+                    path: "/artifacts/device.pcapng",
+                    fields: ["ip.addr", "udp.port", "data.data"],
+                    display_filter: "udp",
+                    decode_as: [],
+                    packet_limit: null,
+                    two_pass: true,
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/compactInputSchema.js

@@ -1,11 +1,9 @@
-import { schemaArrays, schemaChildren, schemaMaps, } from "./inputSchemaPresentation.js";
+import { schemaArrays, schemaChildren, schemaMaps, schemaLiteralValues, } from "./jsonSchemaKeywords.js";
 // Kimi expands schema-local references before sending tools to Moonshot.
 // Compact advertisements must fit after expansion, independently of client
 // reference handling. Canonical server-side validation remains unchanged.
 /** Annotation keys that carry guidance but no validation semantics. */
 const annotationKeys = new Set(["description", "examples", "default", "title"]);
-/** Keys whose values are literal data, never nested schemas to rewrite. */
-const dataKeys = new Set(["const", "enum", "examples", "default"]);
 const definitionKeys = new Set(["$defs", "definitions"]);
 // An empty schema accepts every JSON value. Kimi otherwise infers string.
 const jsonValueTypes = [
@@ -16,8 +14,20 @@ const jsonValueTypes = [
     "number",
     "string",
 ];
+// An empty item schema accepts every JSON value, including arbitrarily nested
+// arrays, while satisfying clients that require `items` for array types.
+const jsonValueSchema = () => ({ type: [...jsonValueTypes], items: {} });
 const isSchemaObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const serializedBytes = (value) => Buffer.byteLength(JSON.stringify(value), "utf8");
+const schemaDepth = (value, depth = 0) => {
+    if (Array.isArray(value))
+        return Math.max(depth, ...value.map((child) => schemaDepth(child, depth + 1)));
+    if (!isSchemaObject(value))
+        return depth;
+    return Math.max(depth, ...Object.values(value).map((child) => schemaDepth(child, depth + 1)));
+};
+/** Strict clients commonly reject advertised schemas deeper than ten nodes. */
+const COMPACT_SCHEMA_MAX_DEPTH = 10;
 /** Rewrite every schema-valued position; literal data stays opaque. */
 const rebuildSchemaPositions = (node, rebuild) => {
     if (Array.isArray(node))
@@ -26,7 +36,7 @@ const rebuildSchemaPositions = (node, rebuild) => {
         return node;
     const out = {};
     for (const [key, value] of Object.entries(node)) {
-        if (dataKeys.has(key)) {
+        if (schemaLiteralValues.has(key)) {
             out[key] = value;
             continue;
         }
@@ -103,7 +113,7 @@ const inlineWithinBudget = (root, budgetBytes) => {
         }
         else if (isSchemaObject(value)) {
             if (position === "schema" && Object.keys(value).length === 0) {
-                yield JSON.stringify({ type: jsonValueTypes });
+                yield JSON.stringify(jsonValueSchema());
                 return;
             }
             if (position === "schema" && typeof value.$ref === "string") {
@@ -193,11 +203,20 @@ const reduceToShallowProperties = (schema) => {
     const properties = isSchemaObject(schema.properties) ? schema.properties : {};
     const description = [
         typeof schema.description === "string" ? schema.description : undefined,
+        ...Object.entries(isSchemaObject(schema.dependentRequired)
+            ? schema.dependentRequired
+            : isSchemaObject(schema.dependencies)
+                ? schema.dependencies
+                : {}).flatMap(([property, partners]) => Array.isArray(partners) &&
+            partners.every((partner) => typeof partner === "string")
+            ? [
+                `When ${property} is provided, also provide ${partners.join(" and ")}.`,
+            ]
+            : []),
         REDUCED_ANNOTATION,
     ]
         .filter((text) => text !== undefined)
         .join(" ");
-    const $schema = typeof schema.$schema === "string" ? { $schema: schema.$schema } : {};
     const shallow = Object.fromEntries(Object.entries(properties).map(([name, value]) => {
         const types = detectedTypes(value, schema);
         const type = types?.length === 1 ? types[0] : types;
@@ -206,11 +225,17 @@ const reduceToShallowProperties = (schema) => {
             : {};
         return [
             name,
-            { ...(type === undefined ? {} : { type }), ...description },
+            {
+                ...(type === undefined ? {} : { type }),
+                // Reduced inputs intentionally omit nested validation, but clients
+                // still require an item schema to accept an array declaration.
+                ...(types?.includes("array") ? { items: jsonValueSchema() } : {}),
+                ...description,
+            },
         ];
     }));
     return {
-        ...$schema,
+        ...(typeof schema.$schema === "string" ? { $schema: schema.$schema } : {}),
         type: "object",
         description,
         properties: shallow,
@@ -220,9 +245,6 @@ const reduceToShallowProperties = (schema) => {
         ...(typeof schema.minProperties === "number"
             ? { minProperties: schema.minProperties }
             : {}),
-        ...(isSchemaObject(schema.dependentRequired)
-            ? { dependentRequired: { ...schema.dependentRequired } }
-            : {}),
         ...(schema.additionalProperties === false
             ? { additionalProperties: false }
             : {}),
@@ -237,7 +259,7 @@ const reduceToShallowProperties = (schema) => {
  */
 export const compactAdvertisedInputSchema = (schema, budgetBytes) => {
     const inline = inlineWithinBudget(stripAnnotations(schema), budgetBytes);
-    if (inline !== undefined)
+    if (inline !== undefined && schemaDepth(inline) <= COMPACT_SCHEMA_MAX_DEPTH)
         return { schema: inline, presentation: "inline" };
     const reduced = reduceToShallowProperties(schema);
     if (serializedBytes(reduced) <= budgetBytes)
@@ -254,3 +276,8 @@ export const compactAdvertisedInputSchema = (schema, budgetBytes) => {
         presentation: "reduced",
     };
 };
+/** Return the JSON schema clients receive for the selected input presentation. */
+export const presentAdvertisedInputSchema = (schema, compactPresentation) => compactPresentation === undefined
+    ? schema
+    : compactAdvertisedInputSchema(schema, compactPresentation.budgetBytes)
+        .schema;

package/dist/contracts/cutterToolContracts.js

@@ -0,0 +1,84 @@
+import { z } from "zod";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "./toolEffects.js";
+/** List live Cutter plugin bridge sessions. */
+export const cutterListInputSchema = z.strictObject({});
+/** Execute a command in a selected live Cutter instance and observed document generation. */
+export const cutterCommandInputSchema = z.strictObject({
+    session_id: z.string().uuid(),
+    expected_generation: z.number().int().nonnegative(),
+    command: z
+        .string()
+        .min(1)
+        .refine((value) => !/[\r\n]/u.test(value), "A single Rizin command line is required"),
+    json: z.boolean().default(false),
+});
+export const cutterSessionSchema = z.strictObject({
+    session_id: z.string().uuid(),
+    pid: z.number().int().positive(),
+    document_generation: z.number().int().nonnegative(),
+    current_file: z.string().nullable(),
+    cutter_version: z.string().nullable(),
+    identity_status: z.literal("partial"),
+});
+export const cutterCommandResultSchema = z.strictObject({
+    command: z.string(),
+    output: jsonValueSchema.nullable(),
+    execution_state: z.enum(["not_started", "complete", "failed", "unknown"]),
+    error: z.string().nullable(),
+    message: z.string().nullable(),
+    output_truncated: z.boolean(),
+    cutter_version: z.string().nullable(),
+    current_file: z.string().nullable(),
+    document_generation: z.number().int().nonnegative(),
+    identity_status: z.literal("partial"),
+});
+export const cutterDiscoverySchema = z.strictObject({
+    sessions: z.array(cutterSessionSchema),
+    bridge_directory: z.string(),
+    discovery_status: z.enum([
+        "sessions_found",
+        "no_live_bridge_found",
+        "bridge_directory_unavailable",
+        "bridge_directory_insecure",
+        "bridge_directory_capacity_exceeded",
+    ]),
+    bridge_directory_security: z.enum([
+        "private_verified",
+        "not_private",
+        "unverified_platform_acl",
+        "not_checked",
+    ]),
+});
+/** Live Cutter discovery and arbitrary Rizin command contracts. */
+export const CUTTER_TOOL_CONTRACTS = [
+    {
+        name: "list_cutter_sessions",
+        ...toolContractMetadata("list_cutter_sessions"),
+        kind: "native-provider",
+        description: "List live REA bridge sessions hosted by upstream Cutter instances, including observed document identity and bridge-directory security status. Discovery admits at most 256 descriptor candidates (16 MiB at the descriptor byte limit), reads and probes at most eight concurrently, and reports bridge_directory_capacity_exceeded rather than claiming no sessions when that budget is exceeded.",
+        inputSchema: cutterListInputSchema,
+        outputSchema: cutterDiscoverySchema,
+        examples: [{ title: "List open Cutter instances", input: {} }],
+    },
+    {
+        name: "cutter_command",
+        ...toolContractMetadata("cutter_command"),
+        kind: "native-provider",
+        description: "Run one arbitrary Rizin command in a selected live Cutter session. Commands may edit and persist analysis state or execute plugin-provided effects; completion uncertainty is returned as Evidence and must not be retried automatically. 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: cutterCommandInputSchema,
+        outputSchema: evidenceResultOf(cutterCommandResultSchema),
+        examples: [
+            {
+                title: "Inspect active binary metadata",
+                input: {
+                    session_id: "00000000-0000-4000-8000-000000000001",
+                    expected_generation: 0,
+                    command: "ij",
+                    json: true,
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/enhancedToolContracts.js

@@ -23,10 +23,10 @@ export const ENHANCED_TOOL_CONTRACTS = [
     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),
+    enhanced("binary_overview", "Return the bound document and exhaustive procedure/string counts, plus every segment and segment_count when the provider supports segment enumeration. If segment fields are omitted, segment coverage is unavailable rather than empty. When every observed segment agrees on an analysis image base, return it as image_base so callers can relate provider addresses to their loader coordinates. 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 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_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. A requested goal is unknown when unresolved expansions prevent proving it absent; 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,20 +1,35 @@
 import { inspectEvmInterfaceInputSchema, evmInterfaceSchema, } from "../../domain/evm/evmInterface.js";
 import { toolContractMetadata } from "../toolEffects.js";
-import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+import { analysisDetailSchema, analysisDetailOutputSchemaOf, } from "../analysisDetail.js";
+import { evmInterfaceSummaryViewResultSchema } from "../../domain/analysisView/analysisView.js";
+/** Delivery selection leaves the existing provider input and original Evidence unchanged. */
+const evmInterfaceInspectionInputSchema = inspectEvmInterfaceInputSchema.extend({
+    detail: analysisDetailSchema.unwrap().optional(),
+});
 /** Target-free EVM capabilities are independent of archive/Apple artifact providers. */
-export const EVM_TOOL_CONTRACTS = [
-    {
-        name: "inspect_evm_interface",
-        ...toolContractMetadata("inspect_evm_interface"),
-        kind: "artifact-provider",
-        description: "Inspect an explicit local flat EVM bytecode carrier and infer dispatch selectors, argument strings and mutability without executing the target or accessing a chain/RPC endpoint. Choose raw or hex encoding explicitly. Returns original carrier and decoded-byte SHA-256, full bytecode and interface candidates inline as inferred Evidence; bytecode kind, hardfork, deployed authenticity and discovery completeness remain unknown. Initial real-verified Linux x64 profile uses unchanged bundled EVMole 0.9.3/WASM in a bounded owned worker; EOF-style EF00 containers are unsupported. No signature lookup, wallet action or transaction broadcast.",
-        inputSchema: inspectEvmInterfaceInputSchema,
-        outputSchema: evidenceResultOf(evmInterfaceSchema),
-        examples: [
-            {
-                title: "Inspect a local runtime bytecode hex carrier",
-                input: { path: "/artifacts/runtime.hex", encoding: "hex" },
+export const INSPECT_EVM_INTERFACE_CONTRACT = {
+    name: "inspect_evm_interface",
+    ...toolContractMetadata("inspect_evm_interface"),
+    kind: "artifact-provider",
+    description: 'Inspect explicit local flat EVM bytecode without target execution or chain/RPC access. Select raw or hex encoding explicitly. Omitted or complete detail returns original carrier and decoded identities, full bytecode and all inferred interface candidates inline. For all inferred selectors/offsets/arguments/mutability and identities without bytecode hex or duplicated stdout, select detail: "summary" on this first call: it retains unchanged complete Evidence and returns a distinct linked inspect_analysis_view summary. Read original function rows or bytecode_hex/stdout/stderr text pages using view kind evm and normalized_result.parent_evidence_id; original complete Evidence remains accessible. Bytecode kind, hardfork, deployed authenticity and discovery completeness stay unknown; summary coverage covers only producer-returned candidates. Unchanged bundled EVMole 0.9.3/WASM in an owned bounded worker is initially real-verified on Linux x64; EOF-style EF00 containers are unsupported. No signature lookup, wallet action or transaction broadcast.',
+    inputSchema: evmInterfaceInspectionInputSchema,
+    outputSchema: analysisDetailOutputSchemaOf(evmInterfaceSchema, evmInterfaceSummaryViewResultSchema),
+    examples: [
+        {
+            title: "Inspect a local runtime bytecode hex carrier",
+            input: { path: "/artifacts/runtime.hex", encoding: "hex" },
+        },
+        {
+            title: "Read every inferred interface candidate without bytecode text",
+            input: {
+                path: "/artifacts/runtime.hex",
+                encoding: "hex",
+                detail: "summary",
             },
-        ],
-    },
+        },
+    ],
+};
+/** Preserve the default catalog's exact operation and ordering. */
+export const EVM_TOOL_CONTRACTS = [
+    INSPECT_EVM_INTERFACE_CONTRACT,
 ];