rea-agents 6.0.0 → 6.2.0

package/dist/contracts/managed/managedWorkflowToolContracts.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { evidenceSchema } from "../../domain/evidence.js";
 import { managedReconstructionImportInputSchema } from "../../domain/managed/managedReconstruction.js";
-import { managedWorkflowOutputSchemas } from "../toolOutputSchemas.js";
+import { managedWorkflowOutputSchemas } from "../toolOutputSchemaGroups.js";
 import { MANAGED_MEMBER_COMPARISON_EXAMPLE, MANAGED_NATIVE_VERIFICATION_EXAMPLE, MANAGED_APPLICATION_GRAPH_EXAMPLE, MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE, } from "./managedWorkflowExamples.js";
 import { toolContractMetadata } from "../toolEffects.js";
 import { requireOutputSchema } from "../toolOutputSchemaPrimitives.js";

package/dist/contracts/mobileApplicationGraphExamples.js

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

package/dist/contracts/native/binaryDiagnosticsToolContracts.js

@@ -1,7 +1,7 @@
 import { inspectRecordedCrashInputSchema, recordedCrashSchema, } from "../../domain/native/recordedCrash.js";
 import { inspectBinaryLayoutInputSchema, binaryLayoutSchema, } from "../../domain/native/binaryLayout.js";
 import { toolContractMetadata } from "../toolEffects.js";
-import { evidenceResultOf } from "../toolOutputSchemas.js";
+import { evidenceResultOf } from "../toolOutputSchemaPrimitives.js";
 /** Offline binary diagnostics are independent of macOS process/UI providers. */
 export const BINARY_DIAGNOSTICS_TOOL_CONTRACTS = [
     {

package/dist/contracts/native/nativeToolContracts.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { nativeCallObservationInputSchema } from "../../domain/native/nativeCallObservation.js";
 import { nativeUiObservationInputSchema, nativeUiScenarioInputSchema, } from "../../domain/native/nativeUiObservation.js";
-import { nativeOutputSchemas } from "../toolOutputSchemas.js";
+import { nativeOutputSchemas } from "../toolOutputSchemaGroups.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { localPathStringSchema } from "../../domain/localPath.js";
 import { toolContractMetadata } from "../toolEffects.js";
 import { requireOutputSchema } from "../toolOutputSchemaPrimitives.js";
 const examples = {
@@ -56,7 +57,8 @@ export const swiftSymbolsSchema = z
     .array(z
     .string()
     .min(1)
-    .regex(/^[^\n]*$/u, "Each Swift symbol must be one line."))
+    .regex(/^[^\n]*$/u, "Each Swift symbol must be one line.")
+    .regex(/^[^\u0000]*$/u, "Swift symbols cannot contain NUL."))
     .min(1);
 /** Provider-neutral semantic operations backed initially by macOS utilities. */
 export const NATIVE_TOOL_CONTRACTS = [
@@ -66,7 +68,7 @@ export const NATIVE_TOOL_CONTRACTS = [
     native("inspect_macho", "Inspect Mach-O slices, load commands, imports, exports, dependencies, build metadata, segments, sections, permissions, and exact command provenance without launching Hopper.", z.object({})),
     native("inspect_signature", "Inspect the active artifact's code-signing identity, hashes, authorities, requirements, entitlements, hardened-runtime state, and exact command provenance.", z.object({})),
     native("inspect_plist", "Parse Info.plist from the active artifact by default, or pass any local plist path. Returns normalized JSON rather than plutil text.", z.object({
-        path: z.string().min(1).optional(),
+        path: localPathStringSchema.optional(),
     })),
     native("list_architectures", "List thin or universal Mach-O slices with offsets, sizes, alignment, explicit coverage, and native-tool provenance.", z.object({})),
     native("demangle_swift", "Demangle an ordered list of single-line Swift symbols without requiring Hopper. Each input returns demangled, unchanged, or invalid status.", z.object({

package/dist/contracts/officialToolContracts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { nativeFunctionAnnotationsInputSchema } from "../domain/native/nativeFunctionAnnotations.js";
-import { officialOutputSchemas, requireOutputSchema, } from "./toolOutputSchemas.js";
+import { officialOutputSchemas } from "./toolOutputSchemaGroups.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
 import { address, document, examplesFor, optionalAddress, procedure, } from "./toolContractHelpers.js";
 import { toolContractMetadata } from "./toolEffects.js";
 import { nativeDataTypeInputSchema } from "../domain/native/nativeDataType.js";
@@ -32,38 +33,37 @@ export const OFFICIAL_TOOL_CONTRACTS = [
     official("current_address", "Return Hopper's current cursor address for the selected document. Use only for interactive navigation state; prefer explicit addresses in reproducible investigations.", z.object({ document })),
     official("current_procedure", "Return the analyzed procedure containing Hopper's current cursor. This uses GUI cursor state and is not a procedure-name lookup.", z.object({ document })),
     official("current_document", "Return the document currently selected by REA's Hopper bridge.", z.object({})),
-    official("goto_address", "Move Hopper's GUI cursor to a hexadecimal address and return the resolved address. This changes navigation state but not analysis data; use explicit-address tools for headless workflows.", z.object({ address, document })),
+    official("goto_address", "Move Hopper's GUI cursor to a mapped address and return the observed cursor address. Interior coordinates snap to the containing analyzed object's start. Unmapped destinations fail without moving the cursor. This changes navigation state but not analysis data; use explicit-address tools for headless workflows.", z.object({ address, document })),
     official("inline_comment", "Read the inline instruction comment at an address, defaulting to the current cursor. Returns null when absent; use set_inline_comment to write one.", z.object({ document, address: optionalAddress })),
-    official("list_bookmarks", "List every bookmark in the selected Hopper document as address and name pairs. Use bookmarks as analyst-authored navigation aids; this does not discover code references.", z.object({ document })),
+    official("list_bookmarks", "List every bookmark in the selected Hopper document as address and name pairs; unnamed bookmarks retain a null name. Use bookmarks as analyst-authored navigation aids; this does not discover code references.", z.object({ document })),
     official("list_documents", "List provider program or document identities. Hopper may expose several documents; a Ghidra headless session contains exactly its one imported Program.", z.object({})),
     official("list_names", "List every analyzed memory and external symbol as address/value pairs. Provider metadata distinguishes Ghidra primary, dynamic, external, type, and source facts when available.", z.object({ document, address: optionalAddress })),
     official("list_procedures", "List every analyzed procedure as address/value pairs after provider analysis. Ghidra metadata distinguishes thunks and external functions; use returned addresses in later function operations.", z.object({ document })),
     official("list_segments", "List segments or memory blocks using exclusive end addresses. Ghidra reports block permissions, address space, image base, initialization, and overlay facts; Hopper marks unavailable permissions explicitly.", z.object({ document })),
-    official("list_strings", "List every provider-defined string, or filter to one address, as address/value pairs. Ghidra also reports encoding, terminator status, and byte length.", z.object({ document, address: optionalAddress })),
+    official("list_strings", "List every provider-defined string object, or filter to one address, as address/value pairs with encoding, terminator status, and byte length when available. Hopper reads complete typed objects and retains its original display text as provider_value; long literals may span adjacent unterminated objects.", z.object({ document, address: optionalAddress })),
     official("next_address", "Return the next analyzed object address after an explicit address or current cursor. This is a navigation primitive, not instruction-flow or CFG analysis.", z.object({ document, address: optionalAddress })),
-    official("prev_address", "Return the previous analyzed instruction start before an explicit address or current cursor. This is a navigation primitive and may fail at document boundaries.", z.object({ document, address: optionalAddress })),
+    official("prev_address", "Return the previous analyzed object start before an explicit address or current cursor. This is a navigation primitive and may fail at document boundaries; data objects and instructions remain distinct from control flow.", z.object({ document, address: optionalAddress })),
     official("procedure_address", "Resolve an unambiguous procedure symbol name or provider-normalized address to its canonical entry address. External address spaces remain explicit.", z.object({ procedure, document })),
     official("procedure_assembly", "Return assembly for one analyzed procedure identified by symbol or hexadecimal address. Use when pseudocode loses calling-convention or instruction-level detail; output is currently returned as one unpaginated string.", z.object({ procedure, document })),
     official("procedure_callees", "Return the provider's resolved direct callees for one procedure identified by symbol or address. Unresolved indirect calls may be absent; use analyze_function and typed references to preserve available edge uncertainty.", z.object({ procedure, document })),
     official("procedure_callers", "Return the provider's resolved direct callers for one procedure identified by symbol or address. Results reflect completed static analysis and may omit unresolved indirect references.", z.object({ procedure, document })),
-    official("procedure_info", "Return provider metadata for one procedure identified by symbol or address: entrypoint, signature, locals, size, block count, and complete inclusive body ranges when observed. Body byte count and enclosing span remain distinct; unavailable extent is explicit.", z.object({ procedure, document })),
+    official("procedure_info", "Return provider metadata for one procedure identified by symbol or address: entrypoint, signature, locals, size, block count, and complete inclusive body ranges when observed. Hopper locals preserve observed names and signed stack displacements; source types remain unknown. Body byte count and enclosing span remain distinct; unavailable extent is explicit.", z.object({ procedure, document })),
     official("read_function_instructions", "Return every raw instruction for one analyzed procedure. Instruction text is provider-specific.", functionInstructionInputSchema),
     ...HOPPER_MEMORY_TOOL_DEFINITIONS.map(({ name, description, inputSchema }) => official(name, description, inputSchema)),
-    official("procedure_references", "Return every raw incoming or outgoing reference edge for one procedure. Endpoint procedures are resolved only from provider containment; Ghidra preserves observed reference kinds while providers without kind authority mark them unavailable.", z.object({
+    official("procedure_references", "Return every raw incoming or outgoing reference edge for one procedure. Endpoint procedures are resolved only from provider containment. Ghidra preserves detailed reference flags. Hopper preserves native CallReference classifications and exact endpoints while leaving unavailable detailed flags explicit.", z.object({
         procedure,
         direction: z.enum(["incoming", "outgoing"]).default("outgoing"),
         document,
     })),
     official("procedure_pseudo_code", "Decompile one analyzed procedure by symbol name or provider-normalized address. Returns provider-specific pseudocode, never original source or cross-provider text equivalence, and may return null; request procedure_assembly when instruction precision matters.", z.object({ procedure, document })),
     official("resolve_containing_procedure", "Resolve an arbitrary address, including an interior instruction or exact external entry, to its provider-analyzed containing procedure. A negative result distinguishes outside segments from not in a procedure and is never guessed from nearby symbols.", z.object({ address, document })),
-    official("search_procedures", "Search every analyzed procedure name using literal matching by default or regex when requested. Results are deterministic and complete.", z.object(analysisSearchInput)),
-    official("search_strings", "Search every analyzed string using literal matching by default or regex when requested. Results are deterministic and complete.", z.object(analysisSearchInput)),
-    official("set_address_name", "Assign an analyst name to one hexadecimal address and report Hopper's boolean result. This mutates analysis metadata.", z.object({ address, name: z.string(), document })),
-    official("set_addresses_names", "Assign analyst names to multiple addresses in one call and return per-address success booleans. This mutates analysis metadata; verify failures individually.", z.object({ names: z.record(z.string(), z.string()), document })),
-    official("set_bookmark", "Create or replace a bookmark at a hexadecimal address and report success. This mutates navigation metadata; bookmarks are analyst-authored navigation aids, not binary evidence.", z.object({ address, name: z.string().optional(), document })),
-    official("set_comment", "Write a regular analysis comment at a hexadecimal address and return whether readback matched. This mutates the Hopper document; use comments to record evidence IDs or reasoning.", z.object({ address, comment: z.string(), document })),
-    official("set_current_document", "Select an already-open Hopper document by exact document name. This changes subsequent default-document routing; list_documents can supply names when needed, while explicit document inputs keep calls reproducible.", z.object({ document: z.string() })),
-    official("set_inline_comment", "Write an inline instruction comment at a hexadecimal address and return whether readback matched. This mutates analysis metadata.", z.object({ address, comment: z.string(), document })),
-    official("unset_bookmark", "Remove the bookmark at a hexadecimal address and return whether it is absent. This mutates navigation metadata and does not alter binary bytes.", z.object({ address, document })),
+    official("search_procedures", "Search every analyzed procedure name using literal matching by default or regex when requested. Results are deterministic and complete. Hopper regex mode uses ECMAScript Unicode syntax in a cancellable worker; a matching deadline leaves its API usable.", z.object(analysisSearchInput)),
+    official("search_strings", "Search every analyzed string object using literal matching by default or regex when requested. Results are deterministic and complete over the native inventory. Hopper retains typed byte decoding, native display, and explicit decoding unknowns. Adjacent long-literal fragments match independently. Hopper regex mode uses ECMAScript Unicode syntax in a cancellable worker; a matching deadline leaves its API usable.", z.object(analysisSearchInput)),
+    official("set_address_name", "Assign an analyst name to one mapped hexadecimal address and report whether the native edit succeeded and exact readback matched. Hopper rejects symbol names exceeding 1024 UTF-16 code units before mutation, and rejects names owned by another address; use set_addresses_names to explicitly move or swap labels among selected addresses. This mutates analysis metadata.", z.object({ address, name: z.string(), document })),
+    official("set_addresses_names", "Assign analyst names to multiple mapped addresses in one call and return per-address edit/readback success booleans. Hopper validates mapped destinations, native string representations, its 1024 UTF-16 code-unit symbol-name limit, and unique destinations/names before applying edits. Existing labels may move or swap only among explicitly selected addresses; unselected label owners remain unchanged. This mutates analysis metadata; verify failures individually.", z.object({ names: z.record(z.string(), z.string()), document })),
+    official("set_bookmark", "Create or replace a bookmark at a mapped hexadecimal address and report success. This mutates navigation metadata; bookmarks are analyst-authored navigation aids, not binary evidence.", z.object({ address, name: z.string().optional(), document })),
+    official("set_comment", "Write a regular analysis comment at a hexadecimal address and return whether readback matched. An empty comment clears it. This mutates the Hopper document; use comments to record evidence IDs or reasoning.", z.object({ address, comment: z.string(), document })),
+    official("set_inline_comment", "Write an inline instruction comment at a hexadecimal address and return whether readback matched. An empty comment clears it; Hopper may flatten newlines, producing false on exact readback. This mutates analysis metadata.", z.object({ address, comment: z.string(), document })),
+    official("unset_bookmark", "Remove the bookmark at a mapped hexadecimal address and return whether it is absent. Hopper also permits removing an existing legacy bookmark outside mapped memory. This mutates navigation metadata and does not alter binary bytes.", z.object({ address, document })),
     official("xrefs", "Return analyzed references to a code or data address. Hopper may default to its current cursor; headless providers such as Ghidra require an explicit address. Use to connect strings, globals, selectors, and functions; bare addresses are untyped and indirect references may be incomplete.", z.object({ document, address: optionalAddress })),
 ];

package/dist/contracts/promptContracts.js

@@ -46,7 +46,7 @@ export const PROMPT_CONTRACTS = [
         arguments: {
             feature: required("Feature, behavior, string, or symbol to investigate"),
             target_path: optional("Absolute target path; omit when the intended target is already open"),
-            document: optional("Open Hopper document to inspect", "document"),
+            document: optional("Active target's provider document name", "document"),
             procedure: optional("Known procedure name or address to prioritize", "procedure"),
             provider_id: optional("Configured provider identity to prefer when its capability is available", "provider"),
         },
@@ -56,16 +56,16 @@ export const PROMPT_CONTRACTS = [
                 instruction: "For a JavaScript/Electron application directory, call analyze_javascript_application with input_path=target_path directly; no open_binary call is needed. For a file or macOS app bundle, open target_path only when the required target is not active.",
             },
             {
-                tools: ["list_documents", "set_current_document"],
-                instruction: "Select a document only when needed for the requested analysis.",
+                tools: ["current_document"],
+                instruction: "Analysis stays bound to the active target's provider document. Use open_binary to switch targets; document names never select another artifact.",
             },
             {
                 tools: ["search_strings", "search_procedures", "procedure_address"],
                 instruction: "Search relevant strings or procedures and analyze the matching procedures; pass names or addresses directly when already known.",
             },
             {
-                tools: ["trace_application_feature"],
-                instruction: "When application-graph Evidence is relevant, trace a route, API, channel, module, string, or native export across layers.",
+                tools: ["inspect_analysis_view", "trace_application_feature"],
+                instruction: "When inspect_binary_layout or analyze_javascript_application Evidence is already retained, call inspect_analysis_view with that evidence_id for a summary, one section/symbol/module, or a stable page. Do not re-run the producer. Use trace_application_feature once a route, API, channel, module, string, or native export seed is known.",
             },
             {
                 tools: [

package/dist/contracts/providerSelection.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 export const analysisProviderIdSchema = z
     .string()
     .min(1)
-    .regex(/^[a-z][a-z0-9-]*$/u)
+    .regex(/^[a-z][a-z0-9\x2d]*$/u)
     .refine((value) => value !== "auto", {
     message: "auto is reserved for provider selection",
 });

package/dist/contracts/sessionLifecycleInputs.js

@@ -1,19 +1,15 @@
 import { executableFormatHintSchema } from "../domain/dosCom.js";
-import { isAbsoluteLocalPath } from "../domain/localPath.js";
+import { isAbsoluteLocalPath, localPathStringSchema, } from "../domain/localPath.js";
 import { z } from "zod";
 import { analysisProviderSelectorSchema } from "./providerSelection.js";
 /** Caller-supplied analysis snapshot path; must name its destination absolutely. */
-const snapshotPathSchema = z
-    .string()
-    .min(1)
+const snapshotPathSchema = localPathStringSchema
     .refine(isAbsoluteLocalPath, {
     message: "snapshot_path must be an absolute local filesystem path (for example /tmp/rea/analysis.json or C:\\rea\\analysis.json)",
 })
     .describe("Absolute local filesystem path for the analysis snapshot; relative paths are rejected.");
 /** Caller-supplied analysis target path; must name the target absolutely. */
-const binaryTargetPathSchema = z
-    .string()
-    .min(1)
+const binaryTargetPathSchema = localPathStringSchema
     .refine(isAbsoluteLocalPath, {
     message: "path must be an absolute local filesystem path (for example /tmp/fixture.bin or C:\\analysis\\fixture.bin)",
 })

package/dist/contracts/sessionStatusContract.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { isAbsoluteLocalPath } from "../domain/localPath.js";
+import { isAbsoluteLocalPath, localPathStringSchema, } from "../domain/localPath.js";
 /** Optional expectations used to compare the live session with its caller. */
 export const binarySessionInputSchema = z.strictObject({
     expected_package_version: z.string().min(1).optional(),
@@ -7,9 +7,7 @@ export const binarySessionInputSchema = z.strictObject({
         .string()
         .regex(/^[a-f0-9]{64}$/u)
         .optional(),
-    expected_server_path: z
-        .string()
-        .min(1)
+    expected_server_path: localPathStringSchema
         .refine(isAbsoluteLocalPath, {
         message: "expected_server_path must be an absolute local filesystem path (for example /opt/rea/dist/main.js)",
     })

package/dist/contracts/sessionToolContracts.js

@@ -1,7 +1,19 @@
 import { z } from "zod";
-import { isAbsoluteLocalPath } from "../domain/localPath.js";
-import { sessionOutputSchemas, requireOutputSchema, } from "./toolOutputSchemas.js";
-import { addressContextInputSchema, artifactComparisonInputSchema, binarySessionInputSchema, bundleComparisonInputSchema, callPathInputSchema, changedBehaviorInputSchema, closeBinaryInputSchema, functionComparisonInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, navigationContextInputSchema, openBinaryInputSchema, processComparisonInputSchema, processScenarioSchema, reconstructionVerificationInputSchema, recordUnknownInputSchema, getEvidenceBundleInputSchema, staticRuntimeCorrelationInputSchema, updateUnknownInputSchema, verifyUnknownResolutionInputSchema, } from "./sessionToolSchemas.js";
+import { isAbsoluteLocalPath, localPathStringSchema, } from "../domain/localPath.js";
+import { artifactComparisonInputSchema } from "../domain/artifactComparison.js";
+import { bundleComparisonInputSchema } from "../domain/bundleComparison.js";
+import { callPathInputSchema } from "../domain/callPathSchemas.js";
+import { changedBehaviorInputSchema } from "../domain/changedBehavior.js";
+import { functionComparisonInputSchema } from "../domain/functionComparisonSchemas.js";
+import { processScenarioSchema } from "../domain/process/processScenario.js";
+import { recordUnknownInputSchema, updateUnknownInputSchema, } from "../domain/residualUnknown.js";
+import { reconstructionVerificationInputSchema } from "../domain/reconstructionVerificationSchemas.js";
+import { staticRuntimeCorrelationInputSchema } from "../domain/staticRuntimeCorrelation.js";
+import { sessionOutputSchemas } from "./toolOutputSchemaGroups.js";
+import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
+import { closeBinaryInputSchema, openBinaryInputSchema, } from "./sessionLifecycleInputs.js";
+import { binarySessionInputSchema } from "./sessionStatusContract.js";
+import { addressContextInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, navigationContextInputSchema, processComparisonInputSchema, getEvidenceBundleInputSchema, verifyUnknownResolutionInputSchema, } from "./sessionToolSchemas.js";
 import { examplesFor } from "./toolContractHelpers.js";
 import { toolContractMetadata } from "./toolEffects.js";
 const session = (name, description, inputSchema) => ({
@@ -15,9 +27,7 @@ const session = (name, description, inputSchema) => ({
 });
 /** Session-owned Evidence bundle export options. */
 export const exportEvidenceBundleInputSchema = z.strictObject({
-    path: z
-        .string()
-        .min(1)
+    path: localPathStringSchema
         .refine(isAbsoluteLocalPath, {
         message: "path must be an absolute local filesystem path (for example /tmp/rea/evidence.json or C:\\rea\\evidence.json)",
     })
@@ -26,8 +36,8 @@ 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. An optional analysis snapshot is imported atomically and must match the binary identity, concrete provider, and canonical analysis profile exactly.", openBinaryInputSchema),
-    session("close_binary", "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. Existing files require explicit overwrite; a failed save leaves the session open so cached analysis is not lost.", closeBinaryInputSchema),
+    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("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),

package/dist/contracts/sessionToolSchemas.js

@@ -1,20 +1,7 @@
 import { z } from "zod";
-import { isAbsoluteLocalPath } from "../domain/localPath.js";
-import { artifactComparisonInputSchema } from "../domain/artifactComparison.js";
-import { bundleComparisonInputSchema } from "../domain/bundleComparison.js";
-import { callPathInputSchema } from "../domain/callPath.js";
-import { changedBehaviorInputSchema } from "../domain/changedBehavior.js";
-import { functionComparisonInputSchema } from "../domain/functionComparison.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { processScenarioSchema } from "../domain/process/processCapture.js";
-import { processTraceSpecificationSchema } from "../domain/process/processTraceComparison.js";
-import { recordUnknownInputSchema } from "../domain/residualUnknown.js";
-import { reconstructionVerificationInputSchema } from "../domain/reconstructionVerification.js";
-import { staticRuntimeCorrelationInputSchema } from "../domain/staticRuntimeCorrelation.js";
+import { isAbsoluteLocalPath, localPathStringSchema, } from "../domain/localPath.js";
+import { processTraceSpecificationSchema } from "../domain/process/processTraceSpecification.js";
 import { evidenceSchema } from "../domain/evidence.js";
-import { updateUnknownInputSchema } from "../domain/residualUnknown.js";
-import { openBinaryInputSchema, closeBinaryInputSchema, } from "./sessionLifecycleInputs.js";
-import { binarySessionInputSchema } from "./sessionStatusContract.js";
 import { prefixedDigestSchema } from "./../domain/digests.js";
 /** Return the current canonical Evidence bundle inline. */
 export const getEvidenceBundleInputSchema = z.strictObject({});
@@ -29,9 +16,7 @@ export const addressContextInputSchema = z.strictObject({
 });
 /** Session-owned Evidence bundle import options. */
 export const importEvidenceBundleInputSchema = z.strictObject({
-    path: z
-        .string()
-        .min(1)
+    path: localPathStringSchema
         .refine(isAbsoluteLocalPath, {
         message: "path must be an absolute local filesystem path (for example /tmp/evidence.json or C:\\rea\\evidence.json)",
     })
@@ -56,4 +41,3 @@ export const listUnknownsInputSchema = z.strictObject({
 export const verifyUnknownResolutionInputSchema = z.strictObject({
     unknown_id: prefixedDigestSchema("unk"),
 });
-export { artifactComparisonInputSchema, binarySessionInputSchema, bundleComparisonInputSchema, callPathInputSchema, changedBehaviorInputSchema, closeBinaryInputSchema, functionComparisonInputSchema, openBinaryInputSchema, processScenarioSchema, reconstructionVerificationInputSchema, recordUnknownInputSchema, staticRuntimeCorrelationInputSchema, updateUnknownInputSchema, };

package/dist/contracts/toolContractExamples.js

@@ -28,7 +28,6 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     set_addresses_names: { names: { "0x1000": "entry" } },
     set_bookmark: { address: "0x1000" },
     set_comment: { address: "0x1000", comment: "validated entry point" },
-    set_current_document: { document: "fixture" },
     set_inline_comment: { address: "0x1000", comment: "calls parser" },
     unset_bookmark: { address: "0x1000" },
     get_call_graph: { address: "0x1000" },

package/dist/contracts/toolContractHelpers.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
-export const document = z.string().optional().describe("The document name");
+export const document = z
+    .string()
+    .optional()
+    .describe("The active target's provider document name; use open_binary to switch targets");
 export const address = z
     .string()
     .describe("A provider-normalized address; default memory uses 0x-prefixed hexadecimal");

package/dist/contracts/toolContracts.js

@@ -1,4 +1,5 @@
 import { EVM_TOOL_CONTRACTS } from "./evm/evmToolContracts.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";
 import { ARTIFACT_TOOL_CONTRACTS } from "./artifactToolContracts.js";
@@ -23,6 +24,7 @@ export const TOOL_CONTRACTS = [
     ...ENHANCED_TOOL_CONTRACTS,
     ...NATIVE_TOOL_CONTRACTS,
     ...BINARY_DIAGNOSTICS_TOOL_CONTRACTS,
+    ...ANALYSIS_VIEW_TOOL_CONTRACTS,
     ...ARTIFACT_TOOL_CONTRACTS,
     ...EVM_TOOL_CONTRACTS,
     ...MANAGED_TOOL_CONTRACTS,

package/dist/contracts/toolEffects.js

@@ -57,6 +57,7 @@ export const TOOL_EFFECTS = {
         writesFilesystem: true,
         launchesProcess: true,
     }),
+    inspect_analysis_view: evidence,
     inspect_firmware_regions: effects({
         mutatesSession: true,
         launchesProcess: true,
@@ -138,7 +139,6 @@ export const TOOL_EFFECTS = {
     set_addresses_names: effects({ mutatesTarget: true, mutatesSession: true }),
     set_bookmark: effects({ mutatesTarget: true, mutatesSession: true }),
     set_comment: effects({ mutatesTarget: true, mutatesSession: true }),
-    set_current_document: effects({ mutatesSession: true, changesUiState: true }),
     set_inline_comment: effects({ mutatesTarget: true, mutatesSession: true }),
     unset_bookmark: effects({
         mutatesTarget: true,