rea-agents 6.3.0 → 6.5.0

package/dist/contracts/rizinDebugToolContracts.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { evidenceResultOf } from "./toolOutputSchemaPrimitives.js";
+import { toolContractMetadata } from "./toolEffects.js";
+const sessionId = z.string().uuid();
+const commandResult = z.strictObject({
+    command: z.string(),
+    output: z.string(),
+    output_scope: z.literal("command_and_interleaved_session_output"),
+    output_truncated: z.boolean(),
+    output_invalid_utf8: z.literal(true).optional(),
+    completion_status: z.enum(["complete", "unknown"]),
+    backend: z.string().nullable(),
+});
+/** Persistent Rizin debugger session contracts. */
+export const RIZIN_DEBUG_TOOL_CONTRACTS = [
+    {
+        name: "start_rizin_debug_session",
+        ...toolContractMetadata("start_rizin_debug_session"),
+        kind: "native-provider",
+        description: "Start a persistent Rizin debugger session using `-N` to suppress user settings and scripts while retaining plugins, `-0` for NUL framing, and `-d` with an optional caller-selected IO debugger backend. Requires a caller-selected Linux TTY for inferior stdout and stderr; the target may write directly to that terminal while running and after detach. REA verifies both destinations and `dbg.exitkills=false` before detaching. Backend and target capabilities depend on the installed build. The session lives in this REA MCP process. Persistent sessions require Linux `/proc` descriptor readback. In a shared MCP server, starting this session 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({
+            path: z.string().min(1),
+            inferior_tty: z.string().min(1),
+            backend: z.string().min(1).optional(),
+        }),
+        outputSchema: z.strictObject({
+            session_id: sessionId,
+            backend: z.string().nullable(),
+        }),
+        examples: [
+            {
+                title: "Start Rizin debugger",
+                input: { path: "/tmp/program", inferior_tty: "/dev/pts/7" },
+            },
+        ],
+    },
+    {
+        name: "rizin_debug_command",
+        ...toolContractMetadata("rizin_debug_command"),
+        kind: "native-provider",
+        description: "Execute one unrestricted command in a persistent Rizin debugger session. Returns raw output inline with Evidence, including backend output interleaved before the completion marker. If the command exceeds the output or frame limit, `output_truncated` is true and `completion_status` is `unknown`; retained partial output is returned and the owned debugger session is stopped. Unsolicited frames already queued before the command make the session unavailable because correlation is ambiguous. Commands can access local files, shell, network, plugins, and target state; effects depend on the active backend and target. 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)
+                .refine((value) => !/[\r\n]/u.test(value), "A single command line is required"),
+        }),
+        outputSchema: evidenceResultOf(commandResult),
+        examples: [
+            {
+                title: "Inspect debugger state",
+                input: {
+                    session_id: "00000000-0000-4000-8000-000000000001",
+                    command: "dr",
+                },
+            },
+        ],
+    },
+    {
+        name: "rizin_debug_session_status",
+        ...toolContractMetadata("rizin_debug_session_status"),
+        kind: "native-provider",
+        description: "Return observed lifecycle state and bounded recent NUL-framed output and process diagnostics for one Rizin debugger session; truncation fields report discarded data, and output_invalid_utf8 reports whether invalid UTF-8 has been observed in session frame bytes; recent output may contain replacement characters.",
+        inputSchema: z.strictObject({ session_id: sessionId }),
+        outputSchema: z.strictObject({
+            session_id: sessionId,
+            state: z.enum(["ready", "closed"]),
+            inferior_tty: z.string(),
+            recent_output: z.array(z.string()),
+            recent_output_truncated: z.boolean(),
+            diagnostics_truncated: z.boolean(),
+            output_invalid_utf8: z.boolean(),
+        }),
+        examples: [
+            {
+                title: "Check Rizin session",
+                input: { session_id: "00000000-0000-4000-8000-000000000001" },
+            },
+        ],
+    },
+    {
+        name: "close_rizin_debug_session",
+        ...toolContractMetadata("close_rizin_debug_session"),
+        kind: "native-provider",
+        description: "Close the REA-owned Rizin debugger only after verifying no inferior remains or detaching one with a verified caller-selected TTY output sink. A detached target may continue running and write to that TTY; target state is otherwise reported as unknown. REA never signals an inferior based on PID or path. 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.literal("unknown") }),
+        examples: [
+            {
+                title: "Close Rizin debugger",
+                input: { session_id: "00000000-0000-4000-8000-000000000001" },
+            },
+        ],
+    },
+];

package/dist/contracts/rust/rustToolContracts.js

@@ -0,0 +1,20 @@
+import { inspectRustBinaryInputSchema, rustBinarySchema, } from "../../domain/rust/rustBinary.js";
+import { toolContractMetadata } from "../toolEffects.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+/** Static Rust dependency metadata is independent of active native-analysis providers. */
+export const RUST_TOOL_CONTRACTS = [
+    {
+        name: "inspect_rust_binary",
+        ...toolContractMetadata("inspect_rust_binary"),
+        kind: "artifact-provider",
+        description: "Inspect the cargo-auditable crate dependency list embedded in an explicit local ELF, PE or thin Mach-O image. Returns the artifact SHA-256, the .dep-v0 section file offset and size, compressed and uncompressed sizes, format version, packages in their original order, the root package index, and dependency edges by index. Reads zlib-compressed JSON without installing Rust, opening a disassembler, executing the target, writing temporary files or accessing the network. A missing section is null metadata with a limitation and is not proof that the binary has no dependencies. A rustc commit hash is reported only as an inference when a /rustc/<40-hex>/ path is present in read-only data. Resource guards bound files to 256 MiB, dependency sections to 1 MiB, inflated JSON to the smaller of 8 MiB and 64 times the compressed size, and the complete report to 8 MiB. Malformed, unsupported and oversized inputs receive typed failures rather than partial success.",
+        inputSchema: inspectRustBinaryInputSchema,
+        outputSchema: evidenceResultOf(rustBinarySchema),
+        examples: [
+            {
+                title: "Inspect an embedded Rust dependency list",
+                input: { path: "/artifacts/application" },
+            },
+        ],
+    },
+];

package/dist/contracts/sessionLifecycleInputs.js

@@ -1,6 +1,7 @@
 import { isAbsolute } from "node:path";
 import { executableFormatHintSchema } from "../domain/dosCom.js";
 import { localPathStringSchema } from "../domain/localPath.js";
+import { binaryArchitectureSchema, rawBinaryEntryPointSchema, rawBinarySelectionError, } from "../domain/rawBinary.js";
 import { z } from "zod";
 import { analysisProviderSelectorSchema } from "./providerSelection.js";
 /** Caller-supplied analysis snapshot path; must name its destination absolutely. */
@@ -16,13 +17,44 @@ const binaryTargetPathSchema = localPathStringSchema
 })
     .describe("Absolute local filesystem path for the analysis target; relative paths are rejected.");
 /** Input contract for opening a target with an optional staged snapshot. */
-export const openBinaryInputSchema = z.strictObject({
+export const openBinaryInputSchema = z
+    .strictObject({
     path: binaryTargetPathSchema,
     format: executableFormatHintSchema
         .optional()
-        .describe("Explicit headerless DOS COM interpretation; omission preserves header-based detection"),
+        .describe("Explicit headerless interpretation: dos-com or raw-binary. Omission preserves header-based detection."),
+    architecture: binaryArchitectureSchema
+        .optional()
+        .describe("Caller-supplied CPU family. Required with format=raw-binary; rejected otherwise."),
+    entry_point: rawBinaryEntryPointSchema
+        .optional()
+        .describe("Caller-supplied load and entry address (0xhex). File offset 0 is mapped here. Required with format=raw-binary; rejected otherwise."),
     provider_id: analysisProviderSelectorSchema.optional(),
     snapshot_path: snapshotPathSchema.optional(),
+})
+    .superRefine((value, context) => {
+    const pairing = rawBinarySelectionError({
+        ...(value.format === undefined ? {} : { format: value.format }),
+        ...(value.architecture === undefined
+            ? {}
+            : { architecture: value.architecture }),
+        ...(value.entry_point === undefined
+            ? {}
+            : { entryPoint: value.entry_point }),
+    });
+    if (pairing === undefined)
+        return;
+    context.addIssue({
+        code: "custom",
+        path: value.format === "raw-binary"
+            ? value.architecture === undefined
+                ? ["architecture"]
+                : ["entry_point"]
+            : value.architecture === undefined
+                ? ["entry_point"]
+                : ["architecture"],
+        message: pairing,
+    });
 });
 /** Input contract for closing a target after an optional atomic snapshot. */
 export const closeBinaryInputSchema = z.strictObject({

package/dist/contracts/sessionToolContracts.js

@@ -37,12 +37,12 @@ export const exportEvidenceBundleInputSchema = z.strictObject({
 });
 /** Target lifecycle tools available only on the long-lived MCP adapter. */
 export const SESSION_TOOL_CONTRACTS = [
-    session("open_binary", "Open a local executable, application bundle, archive, JavaScript, source map, plist, or analysis database after validation. format=dos-com explicitly interprets 1..65280 headerless bytes as a DOS COM analysis image; omission preserves header-based detection. provider_id selects one deep provider or deterministic auto selection; the binding remains stable until close or an explicit switch, with no failure fallback. Reopening the same target and profile retains its active database and metadata edits. An optional analysis snapshot is imported atomically and must match the binary identity, concrete provider, and canonical analysis profile exactly; importing into a session with metadata mutations requires closing and reopening it first.", openBinaryInputSchema),
+    session("open_binary", "Open a local executable, application bundle, archive, JavaScript, source map, plist, or analysis database after validation. format=dos-com explicitly interprets 1..65280 headerless bytes as a DOS COM analysis image. format=raw-binary interprets headerless bytes with a required architecture and entry_point; file offset 0 maps at that address. Omission preserves header-based detection. provider_id selects one deep provider or deterministic auto selection; the binding remains stable until close or an explicit switch, with no failure fallback. Reopening the same target and profile retains its active database and metadata edits. An optional analysis snapshot is imported atomically and must match the binary identity, concrete provider, and canonical analysis profile exactly; importing into a session with metadata mutations requires closing and reopening it first.", openBinaryInputSchema),
     session("close_binary", "Drain earlier provider requests, optionally write a provider-neutral analysis snapshot atomically to the caller-supplied path, then close the active target and every provider resource started for it. Later provider requests wait until this lifecycle operation finishes. Existing files require explicit overwrite; a failed save leaves the session open so cached analysis is not lost. Metadata edits prevent immutable snapshot saves until the session is recreated; export_evidence_bundle preserves mutable observations before closing without a snapshot.", closeBinaryInputSchema),
     session("binary_session", "Report the complete current target, provider, capability availability, client-feature, analysis, and server-identity status without starting analysis.", binarySessionInputSchema),
     session("export_evidence_bundle", "Atomically write the session's deterministic Evidence bundle to the requested local path. Existing files require overwrite: true; records and manifests use canonical byte-stable ordering.", exportEvidenceBundleInputSchema),
     session("import_evidence_bundle", "Read the JSON bundle at the supplied local path, validate every Evidence ID and canonical manifest, then atomically merge it. Imported content is data only and is never executed.", importEvidenceBundleInputSchema),
-    session("capture_process_scenario", "Run one caller-selected command under a PTY and return process capture Evidence with residual unknowns. A command name resolves through the inherited PATH; the working directory defaults to the caller's current directory; host environment variables are inherited with scenario overrides. Environment keys cannot contain '=' or NUL, and REA_PROCESS_RUN_ID is reserved for process ownership. Filesystem snapshots are opt-in through filesystem_observation_paths. The target runs with the current user's permissions; this is not a security sandbox.", processScenarioSchema),
+    session("capture_process_scenario", "Run one caller-selected command under a PTY and return process capture Evidence with residual unknowns. The renderer admits at most 1,000,000 combined terminal cells, computed as columns × (rows + scrollback); every resize uses the selected scrollback and must fit the same budget. Supply a smaller terminal shape when that product is too large; dimensions are never clamped. A command name resolves through the inherited PATH; the working directory defaults to the caller's current directory; host environment variables are inherited with scenario overrides. Environment keys cannot contain '=' or NUL, and REA_PROCESS_RUN_ID is reserved for process ownership. Filesystem snapshots are opt-in through filesystem_observation_paths. A positive finalization_ms makes a timeout or idle deadline send SIGTERM to the captured root through its start identity, keep observing, and send SIGKILL once after the interval; exit.finalization records each attempt with its delivery result and the observed exit, and cancellation still ends the run at once. The target runs with the current user's permissions; this is not a security sandbox.", processScenarioSchema),
     session("compare_process_captures", "Compare two compatible process capture observations across terminal, interaction, lifecycle, process, filesystem, command-shim, HTTP, and WebSocket evidence. Optional trace_spec validates exact events against an explicit partial order or finite trace language; concurrency is never inferred from timestamps or broad sorting. Missing, journal-free, or truncated observations are never treated as equivalent.", processComparisonInputSchema),
     session("compare_artifacts", "Compare complete artifact inventories by logical occurrence path, content identity, metadata, and graph relations. Pass the inventory Evidence nested in each inspect_artifact result as left and right. Every delta cites both inputs, and gaps yield truncated or unknown, never equivalence. Returns every change inline.", artifactComparisonInputSchema),
     session("compare_functions", "Compare two explicit sets of analyze_function Evidence across identity, exact provider text, calls, references, strings, and address-normalized CFG topology. Missing or provider-incompatible facets remain truncated or unknown; every conclusion cites both Evidence sets.", functionComparisonInputSchema),
@@ -51,11 +51,11 @@ export const SESSION_TOOL_CONTRACTS = [
     session("build_call_path", "Build every shortest direct-callee path inline from complete analyze_function Evidence records using exact canonical addresses. Missing dossiers and provider mixing remain unknown; every node and edge cites source Evidence.", callPathInputSchema),
     session("correlate_static_and_runtime", "Evaluate every explicit caller-declared hypothesis between exact static comparison findings and runtime comparison dimensions. Similar names or paths are never auto-matched, consistent cochange never proves causality, and unknown or truncated inputs remain unresolved. Returns all correlations and their complete Evidence closure inline.", staticRuntimeCorrelationInputSchema),
     session("verify_reconstruction", "Verify a finite typed behavioral and structural specification against a canonical Evidence bundle. Pass means every declared claim has complete comparable authority—not global source equivalence; changed claims fail and missing, limited, or unresolved evidence stays unknown.", reconstructionVerificationInputSchema),
-    session("list_unknowns", "List every current residual-unknown head in deterministic ID order, with optional exact status, severity, and domain filters. Results are complete and inline. This is read-only; unresolved, contradicted, and non-truth dispositions remain distinct.", listUnknownsInputSchema),
+    session("list_unknowns", "List current residual-unknown heads in deterministic ID order, with optional exact status, severity, and domain filters. Results are complete inline by default; supply offset and limit to page the filtered order. total is the matching-head count and next_offset is null when the page exhausts the result. This is read-only; unresolved, contradicted, and non-truth dispositions remain distinct.", listUnknownsInputSchema),
     session("record_unknown", "Create one deterministic residual unknown and immutable mutation evidence. Validates all evidence and relationship references, and rejects duplicate stable identity.", recordUnknownInputSchema),
     session("update_unknown", "Append one immutable full-state revision and mutation evidence. Requires exact expected_revision; stale concurrent writers fail instead of overwriting newer analysis.", updateUnknownInputSchema),
     session("verify_unknown_resolution", "Revalidate the current residual-unknown head against live bundled evidence, exact authority/confidence/environment requirements, and revision integrity. Withdrawn and out-of-scope dispositions are not truth claims.", verifyUnknownResolutionInputSchema),
-    session("get_evidence_bundle", "Return every Evidence record and residual unknown currently retained by this session as one inline bundle for direct inspection or follow-up workflows.", getEvidenceBundleInputSchema),
+    session("get_evidence_bundle", "Return every retained Evidence record and residual unknown as a complete canonical bundle by default. detail=summary discovers retained records without copying or transferring their payloads; optionally filter by exact Evidence ID, operation, target SHA-256, analysis-profile digest or canonical native procedure address. Metadata distinguishes complete record retention from native value-flow truncation or unavailable/unknown coverage. Use a discovered evidence_id with inspect_analysis_view without restarting a provider. Filters apply only to summary delivery.", getEvidenceBundleInputSchema),
     session("get_navigation_context", "Return the selected document, current address, and containing/current procedure in one provider-neutral result. The result reflects sequential provider observations, not an atomic cursor snapshot; a cursor outside any procedure returns procedure: null.", navigationContextInputSchema),
     session("inspect_address_context", "Inspect one explicit reproducible address for its analyzed name, containing procedure, regular and inline comments, and matching bookmarks. Each unsupported facet returns a typed unavailable outcome; use xrefs, assembly, or pseudocode for those deeper views.", addressContextInputSchema),
 ];

package/dist/contracts/sessionToolSchemas.js

@@ -4,8 +4,12 @@ import { localPathStringSchema } from "../domain/localPath.js";
 import { processTraceSpecificationSchema } from "../domain/process/processTraceSpecification.js";
 import { evidenceSchema } from "../domain/evidence.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
-/** Return the current canonical Evidence bundle inline. */
-export const getEvidenceBundleInputSchema = z.strictObject({});
+import { evidenceRecordFiltersSchema } from "../domain/evidenceRecordSummary.js";
+/** Complete retained Evidence, or selected discovery metadata without payloads. */
+export const getEvidenceBundleInputSchema = z.strictObject({
+    detail: z.enum(["complete", "summary"]).default("complete"),
+    filters: evidenceRecordFiltersSchema.optional(),
+});
 /** Optional document selection for volatile navigation context. */
 export const navigationContextInputSchema = z.strictObject({
     document: z.string().min(1).optional(),
@@ -37,6 +41,20 @@ export const listUnknownsInputSchema = z.strictObject({
         .optional(),
     severity: z.enum(["low", "medium", "high", "critical"]).optional(),
     domain: z.string().trim().min(1).optional(),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .max(Number.MAX_SAFE_INTEGER)
+        .default(0)
+        .describe("Zero-based offset in the stable filtered unknown ID order."),
+    limit: z
+        .number()
+        .int()
+        .positive()
+        .max(Number.MAX_SAFE_INTEGER)
+        .optional()
+        .describe("Optional maximum number of heads to return. Omit to return every matching head from offset."),
 });
 /** Exact residual-unknown identity to revalidate. */
 export const verifyUnknownResolutionInputSchema = z.strictObject({

package/dist/contracts/signals/signalToolContracts.js

@@ -0,0 +1,40 @@
+import { inspectSignalDecodersInputSchema, signalDecodersSchema, } from "../../domain/signals/signalDecoders.js";
+import { decodeSignalRecordingInputSchema, signalRecordingSchema, } from "../../domain/signals/signalRecording.js";
+import { toolContractMetadata } from "../toolEffects.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+export const SIGNAL_TOOL_CONTRACTS = [
+    {
+        name: "inspect_signal_decoders",
+        ...toolContractMetadata("inspect_signal_decoders"),
+        kind: "artifact-provider",
+        description: "Discover installed sigrok protocol decoders or inspect one decoder's channel/option help on Linux. Omit decoder to list ID/name pairs; supply its exact ID for literal help lines with source line numbers. query is a case-insensitive literal substring. Page matches with offset/limit (default 50; null returns all remaining). Reports tool identity, version, diagnostics and examined/matching coverage. Uses configured REA_SIGROK_COMMAND and prlimit; no recording, binary target, hardware scan or acquisition. Each call probes again; decoder modules are trusted, not fully fingerprinted. Use returned IDs/options with decode_signal_recording.",
+        inputSchema: inspectSignalDecodersInputSchema,
+        outputSchema: evidenceResultOf(signalDecodersSchema),
+        examples: [
+            { title: "Find installed UART decoders", input: { query: "uart" } },
+            {
+                title: "Read the installed UART baud-rate option",
+                input: { decoder: "uart", query: "baud" },
+            },
+        ],
+    },
+    {
+        name: "decode_signal_recording",
+        ...toolContractMetadata("decode_signal_recording"),
+        kind: "artifact-provider",
+        description: "Decode an existing local logic/signal recording on Linux with sigrok-cli 0.7.2 and util-linux prlimit. Supply decoder stack, channels and options explicitly; optionally select input format and annotation classes. Return 50 literal output lines by default, with line_offset/line_limit paging; line_limit:null requests all remaining lines. Output windows count display lines, not annotations or samples, and do not shorten decoding. Preserve selected text, sample ranges, stderr, source/tool identity and coverage inline. Configure absolute REA_SIGROK_COMMAND. File-only analysis; no hardware acquisition or device communication. Empty output does not prove absence of traffic.",
+        inputSchema: decodeSignalRecordingInputSchema,
+        outputSchema: evidenceResultOf(signalRecordingSchema),
+        examples: [
+            {
+                title: "Decode recorded UART RX bytes",
+                input: {
+                    path: "/artifacts/uart.vcd",
+                    input_format: "vcd",
+                    decoders: "uart:rx=RX:baudrate=9600",
+                    annotations: "uart=rx-data",
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/sqlite/sqliteToolContracts.js

@@ -0,0 +1,36 @@
+import { inspectSqliteDatabaseInputSchema, sqliteDatabaseSchema, } from "../../domain/sqlite/sqliteDatabase.js";
+import { toolContractMetadata } from "../toolEffects.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
+/** Snapshot inspection is independent of any active native-analysis target. */
+export const SQLITE_TOOL_CONTRACTS = [
+    {
+        name: "inspect_sqlite_database",
+        ...toolContractMetadata("inspect_sqlite_database"),
+        kind: "artifact-provider",
+        description: "Inspect an explicit local SQLite database snapshot and its existing sibling WAL without modifying source files or opening a native analysis provider. Requires Node.js 24.x >=24.15 or 26+ with native DatabaseSync.limits support, checked by the worker. Returns observed Evidence with database/WAL SHA-256 and a compact schema inventory. Selecting an exact ordinary table expands only its schema and samples rows (default 20, subject to byte and worker resource limits). Select exact columns in the requested order to avoid unrelated or large values; schema_scope=database explicitly expands the whole schema; returned rows retain 64-bit integers, text bytes and blobs with explicit truncation. No arbitrary SQL, view or virtual-table execution, extension loading, database repair, encryption support or live-snapshot atomicity claim. At most two inspections per provider are admitted; occupied capacity is retryable. An isolated temporary copy and owned worker enforce input, value/record, SQL-statement, JSON-reply, JavaScript-heap and deadline limits; overall native heap is not capped. Supply a quiescent snapshot for coherent database/WAL evidence.",
+        inputSchema: inspectSqliteDatabaseInputSchema,
+        outputSchema: evidenceResultOf(sqliteDatabaseSchema),
+        examples: [
+            {
+                title: "Inspect a compact inventory of a local SQLite snapshot",
+                input: { path: "/artifacts/application.sqlite" },
+            },
+            {
+                title: "Read selected rows from an ordinary table",
+                input: {
+                    path: "/artifacts/application.sqlite",
+                    table: "settings",
+                    columns: ["key", "value"],
+                    row_limit: 20,
+                },
+            },
+            {
+                title: "Expand the complete stored schema",
+                input: {
+                    path: "/artifacts/application.sqlite",
+                    schema_scope: "database",
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/toolContractExamples.js

@@ -18,6 +18,7 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     resolve_native_call_targets: { address: "0x1000" },
     read_function_instructions: { procedure: "main" },
     read_bytes: { address: "0x1000", length: 16 },
+    search_bytes: { pattern: "48 8B ?? ?? 89" },
     address_to_file_offset: { address: "0x1000" },
     procedure_references: { procedure: "main" },
     procedure_pseudo_code: { procedure: "main" },
@@ -45,11 +46,17 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     trace_native_ui_action: { action: "buildTapped:" },
     open_binary: { path: "/tmp/fixture" },
     export_evidence_bundle: { path: "/tmp/evidence.json" },
+    get_evidence_bundle: {
+        detail: "summary",
+        filters: { operation: "analyze_function", procedure_address: "0x1000" },
+    },
     inspect_address_context: { address: "0x1000" },
     import_evidence_bundle: { path: "/tmp/evidence.json" },
     capture_process_scenario: {
         executable: "/usr/bin/true",
         working_directory: "/tmp",
+        timeout_ms: 30_000,
+        finalization_ms: 1_500,
     },
     compare_process_captures: {
         left: PROCESS_CAPTURE_REFERENCE,
@@ -67,4 +74,32 @@ export const TOOL_EXAMPLE_OVERRIDES = {
         left_bundle_path: "/tmp/left-evidence.json",
         right_bundle_path: "/tmp/right-evidence.json",
     },
+    inspect_with_objdump: {
+        path: "/tmp/program",
+        operation: "disassemble",
+    },
+    execute_rizin_command: { path: "/tmp/program", command: "iI" },
+    list_frida_devices: {},
+    list_frida_processes: { device_id: "local" },
+    start_frida_session: { mode: "attach", device_id: "local", pid: 1234 },
+    load_frida_script: {
+        session_id: "00000000-0000-4000-8000-000000000001",
+        source_kind: "inline",
+        source: "send(Process.id);",
+    },
+    resume_frida_session: { session_id: "00000000-0000-4000-8000-000000000001" },
+    unload_frida_script: {
+        session_id: "00000000-0000-4000-8000-000000000001",
+        script_id: "00000000-0000-4000-8000-000000000002",
+    },
+    frida_session_status: { session_id: "00000000-0000-4000-8000-000000000001" },
+    close_frida_session: { session_id: "00000000-0000-4000-8000-000000000001" },
+    instrument_with_frida: {
+        mode: "attach",
+        device_id: "local",
+        pid: 1234,
+        source_kind: "inline",
+        source: "send(Process.id);",
+        duration_ms: 1_000,
+    },
 };

package/dist/contracts/toolContractTypes.js

@@ -6,10 +6,15 @@ export const TOOL_KINDS = [
     "artifact-provider",
     "managed-provider",
     "android-provider",
+    "apktool-provider",
+    "flutter-provider",
+    "jeb-provider",
+    "adb-provider",
     "firmware-provider",
     "browser-provider",
     "electron-provider",
     "runtime-provider",
+    "pcap-provider",
     "application",
     "session",
 ];

package/dist/contracts/toolContracts.js

@@ -1,4 +1,10 @@
+import { CAPTURE_TOOL_CONTRACTS } from "./captures/captureToolContracts.js";
+import { SIGNAL_TOOL_CONTRACTS } from "./signals/signalToolContracts.js";
+import { WASM_TOOL_CONTRACTS } from "./wasm/wasmToolContracts.js";
 import { EVM_TOOL_CONTRACTS } from "./evm/evmToolContracts.js";
+import { GO_TOOL_CONTRACTS } from "./go/goToolContracts.js";
+import { RUST_TOOL_CONTRACTS } from "./rust/rustToolContracts.js";
+import { SQLITE_TOOL_CONTRACTS } from "./sqlite/sqliteToolContracts.js";
 import { ANALYSIS_VIEW_TOOL_CONTRACTS } from "./analysisViewToolContracts.js";
 import { BINARY_DIAGNOSTICS_TOOL_CONTRACTS } from "./native/binaryDiagnosticsToolContracts.js";
 import { NATIVE_TOOL_CONTRACTS } from "./native/nativeToolContracts.js";
@@ -6,6 +12,11 @@ import { ARTIFACT_TOOL_CONTRACTS } from "./artifactToolContracts.js";
 import { MANAGED_TOOL_CONTRACTS } from "./managed/managedToolContracts.js";
 import { FIRMWARE_TOOL_CONTRACTS } from "./firmware/firmwareToolContracts.js";
 import { ANDROID_TOOL_CONTRACTS } from "./android/androidToolContracts.js";
+import { APKTOOL_TOOL_CONTRACTS } from "./apktool/apktoolToolContracts.js";
+import { PCAP_TOOL_CONTRACTS } from "./pcap/pcapToolContracts.js";
+import { FLUTTER_TOOL_CONTRACTS } from "./flutter/flutterToolContracts.js";
+import { JEB_TOOL_CONTRACTS } from "./jeb/jebToolContracts.js";
+import { ADB_TOOL_CONTRACTS } from "./adb/adbToolContracts.js";
 import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "./managed/managedWorkflowToolContracts.js";
 import { BROWSER_PROVIDER_TOOL_CONTRACTS } from "./browserProviderToolContracts.js";
 import { ELECTRON_TOOL_CONTRACTS } from "./javascript/electronToolContracts.js";
@@ -18,6 +29,11 @@ import { JAVASCRIPT_RECOVERY_TOOL_CONTRACTS } from "./javascript/javascriptRecov
 import { OFFICIAL_TOOL_CONTRACTS } from "./officialToolContracts.js";
 import { ENHANCED_TOOL_CONTRACTS } from "./enhancedToolContracts.js";
 import { SESSION_TOOL_CONTRACTS } from "./sessionToolContracts.js";
+import { CUTTER_TOOL_CONTRACTS } from "./cutterToolContracts.js";
+import { REVERSE_ENGINEERING_TOOL_CONTRACTS } from "./reverseEngineeringToolContracts.js";
+import { GDB_TOOL_CONTRACTS } from "./gdbToolContracts.js";
+import { RIZIN_DEBUG_TOOL_CONTRACTS } from "./rizinDebugToolContracts.js";
+import { FRIDA_TOOL_CONTRACTS } from "./fridaToolContracts.js";
 /** Complete ordered public inventory used by registration and verification. */
 export const TOOL_CONTRACTS = [
     ...OFFICIAL_TOOL_CONTRACTS,
@@ -27,8 +43,19 @@ export const TOOL_CONTRACTS = [
     ...ANALYSIS_VIEW_TOOL_CONTRACTS,
     ...ARTIFACT_TOOL_CONTRACTS,
     ...EVM_TOOL_CONTRACTS,
+    ...GO_TOOL_CONTRACTS,
+    ...RUST_TOOL_CONTRACTS,
+    ...WASM_TOOL_CONTRACTS,
+    ...SQLITE_TOOL_CONTRACTS,
+    ...CAPTURE_TOOL_CONTRACTS,
+    ...SIGNAL_TOOL_CONTRACTS,
     ...MANAGED_TOOL_CONTRACTS,
     ...ANDROID_TOOL_CONTRACTS,
+    ...APKTOOL_TOOL_CONTRACTS,
+    ...PCAP_TOOL_CONTRACTS,
+    ...FLUTTER_TOOL_CONTRACTS,
+    ...JEB_TOOL_CONTRACTS,
+    ...ADB_TOOL_CONTRACTS,
     ...FIRMWARE_TOOL_CONTRACTS,
     ...MANAGED_WORKFLOW_TOOL_CONTRACTS,
     ...BROWSER_PROVIDER_TOOL_CONTRACTS,
@@ -40,6 +67,11 @@ export const TOOL_CONTRACTS = [
     ...WEB_NETWORK_CAPTURE_TOOL_CONTRACTS,
     ...JAVASCRIPT_RECOVERY_TOOL_CONTRACTS,
     ...SESSION_TOOL_CONTRACTS,
+    ...CUTTER_TOOL_CONTRACTS,
+    ...REVERSE_ENGINEERING_TOOL_CONTRACTS,
+    ...GDB_TOOL_CONTRACTS,
+    ...RIZIN_DEBUG_TOOL_CONTRACTS,
+    ...FRIDA_TOOL_CONTRACTS,
 ];
 /** Resolve a public contract by name while retaining its exact schema types. */
 export const toolContract = (name) => {