rea-agents 1.6.0 → 2.0.0

package/dist/contracts/managedWorkflowToolContracts.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { compareManagedMembersInputSchema } from "../domain/managedMemberComparison.js";
+import { managedNativeVerificationInputSchema } from "../domain/managedNativeVerification.js";
+import { managedReconstructionImportInputSchema } from "../domain/managedReconstruction.js";
+import { managedRuntimeCorrelationInputSchema } from "../domain/managedRuntimeCorrelation.js";
+import { projectManagedApplicationGraphInputSchema } from "../domain/managedApplicationGraph.js";
+import { managedWorkflowOutputSchemas } from "./toolOutputSchemas.js";
+import { MANAGED_MEMBER_COMPARISON_EXAMPLE, MANAGED_NATIVE_VERIFICATION_EXAMPLE, MANAGED_APPLICATION_GRAPH_EXAMPLE, MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE, MANAGED_RUNTIME_CORRELATION_EXAMPLE, } from "./managedWorkflowExamples.js";
+import { toolContractMetadata } from "./toolEffects.js";
+const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
+const managedEvidenceIdSchema = evidenceIdSchema.describe("Session-owned inspect_managed_members Evidence ID");
+const managedArtifactEvidenceIdSchema = evidenceIdSchema.describe("Session-owned inspect_managed_artifact Evidence ID");
+const managedBoundaryEvidenceIdSchema = evidenceIdSchema.describe("Session-owned inspect_managed_native_boundaries Evidence ID");
+const nativeObservationEvidenceIdSchema = evidenceIdSchema.describe("Session-owned inspect_macho or analyze_function Evidence ID");
+/** MCP references for comparing two session-owned managed observations. */
+export const compareManagedMembersReferenceInputSchema = z
+    .strictObject({
+    left_evidence_id: managedEvidenceIdSchema,
+    right_evidence_id: managedEvidenceIdSchema,
+    limits: compareManagedMembersInputSchema.shape.limits,
+    unknown_registry_approved: compareManagedMembersInputSchema.shape.unknown_registry_approved,
+})
+    .superRefine((input, context) => {
+    if (input.left_evidence_id === input.right_evidence_id)
+        context.addIssue({
+            code: "custom",
+            path: ["right_evidence_id"],
+            message: "Managed member Evidence must be distinct",
+        });
+});
+/** MCP reference for planning from one session-owned managed observation. */
+export const managedRuntimeCorrelationReferenceInputSchema = managedRuntimeCorrelationInputSchema
+    .omit({ static_members: true })
+    .extend({ static_members_evidence_id: managedEvidenceIdSchema });
+/** MCP reference for importing reconstruction against session Evidence. */
+export const managedReconstructionReferenceInputSchema = managedReconstructionImportInputSchema
+    .omit({ static_members: true })
+    .extend({ static_members_evidence_id: managedEvidenceIdSchema });
+/** MCP references for managed/native verification from session Evidence. */
+export const managedNativeVerificationReferenceInputSchema = z
+    .strictObject({
+    managed_boundaries_evidence_id: managedBoundaryEvidenceIdSchema,
+    native_observation_evidence_ids: z
+        .array(nativeObservationEvidenceIdSchema)
+        .min(1)
+        .max(50)
+        .describe("Unique session-owned native observation Evidence IDs"),
+    limits: managedNativeVerificationInputSchema.shape.limits,
+    unknown_registry_approved: managedNativeVerificationInputSchema.shape.unknown_registry_approved,
+})
+    .superRefine((input, context) => {
+    const ids = new Set();
+    for (const [index, evidenceId,] of input.native_observation_evidence_ids.entries()) {
+        if (evidenceId === input.managed_boundaries_evidence_id)
+            context.addIssue({
+                code: "custom",
+                path: ["native_observation_evidence_ids", index],
+                message: "Native observation Evidence must be distinct from managed boundary Evidence",
+            });
+        if (ids.has(evidenceId))
+            context.addIssue({
+                code: "custom",
+                path: ["native_observation_evidence_ids", index],
+                message: "Native observation Evidence IDs must be unique",
+            });
+        ids.add(evidenceId);
+    }
+});
+/** MCP references for projecting managed Evidence into an application graph. */
+export const managedApplicationGraphReferenceInputSchema = z
+    .strictObject({
+    managed_artifact_evidence_id: managedArtifactEvidenceIdSchema.optional(),
+    managed_members_evidence_id: managedEvidenceIdSchema.optional(),
+    managed_native_boundaries_evidence_id: managedBoundaryEvidenceIdSchema.optional(),
+    limits: projectManagedApplicationGraphInputSchema.shape.limits,
+})
+    .superRefine((input, context) => {
+    const ids = [
+        input.managed_artifact_evidence_id,
+        input.managed_members_evidence_id,
+        input.managed_native_boundaries_evidence_id,
+    ].filter((id) => id !== undefined);
+    if (ids.length === 0)
+        context.addIssue({
+            code: "custom",
+            message: "At least one managed Evidence ID is required",
+        });
+    if (new Set(ids).size !== ids.length)
+        context.addIssue({
+            code: "custom",
+            message: "Managed application graph Evidence IDs must be unique",
+        });
+});
+const comparisonOutputSchema = managedWorkflowOutputSchemas.compare_managed_members;
+if (comparisonOutputSchema === undefined)
+    throw new Error("Missing managed workflow output schema for compare_managed_members");
+const runtimeOutputSchema = managedWorkflowOutputSchemas.plan_managed_runtime_correlation;
+if (runtimeOutputSchema === undefined)
+    throw new Error("Missing managed workflow output schema for plan_managed_runtime_correlation");
+const reconstructionOutputSchema = managedWorkflowOutputSchemas.import_managed_reconstruction;
+if (reconstructionOutputSchema === undefined)
+    throw new Error("Missing managed workflow output schema for import_managed_reconstruction");
+const nativeVerificationOutputSchema = managedWorkflowOutputSchemas.verify_managed_native_boundaries;
+if (nativeVerificationOutputSchema === undefined)
+    throw new Error("Missing managed workflow output schema for verify_managed_native_boundaries");
+const managedApplicationGraphOutputSchema = managedWorkflowOutputSchemas.project_managed_application_graph;
+if (managedApplicationGraphOutputSchema === undefined)
+    throw new Error("Missing managed workflow output schema for project_managed_application_graph");
+/** Provider-neutral managed-code workflow contracts. */
+export const MANAGED_WORKFLOW_TOOL_CONTRACTS = [
+    {
+        name: "compare_managed_members",
+        ...toolContractMetadata("compare_managed_members"),
+        description: "Compare two authenticated inspect_managed_members Evidence records using unique-only CIL/signature and structural method-shape tiers. Names are reported as observations but are not used as a matching basis; metadata tokens are remapped as build-local coordinates bound to each artifact SHA-256 and MVID.",
+        kind: "application",
+        inputSchema: compareManagedMembersReferenceInputSchema,
+        outputSchema: comparisonOutputSchema,
+        examples: [
+            {
+                title: "Compare two managed member observations",
+                input: {
+                    left_evidence_id: MANAGED_MEMBER_COMPARISON_EXAMPLE.left.evidence_id,
+                    right_evidence_id: MANAGED_MEMBER_COMPARISON_EXAMPLE.right.evidence_id,
+                    limits: MANAGED_MEMBER_COMPARISON_EXAMPLE.limits,
+                },
+            },
+        ],
+    },
+    {
+        name: "verify_managed_native_boundaries",
+        ...toolContractMetadata("verify_managed_native_boundaries"),
+        description: "Verify managed P/Invoke/native-boundary declarations against authenticated native export or function Evidence without executing managed code or translating managed metadata tokens into native addresses. The workflow preserves declaration-only, verified, inferred, contradicted, and unresolved states.",
+        kind: "application",
+        inputSchema: managedNativeVerificationReferenceInputSchema,
+        outputSchema: nativeVerificationOutputSchema,
+        examples: [
+            {
+                title: "Verify a managed P/Invoke declaration against native Evidence",
+                input: {
+                    managed_boundaries_evidence_id: MANAGED_NATIVE_VERIFICATION_EXAMPLE.managed_boundaries.evidence_id,
+                    native_observation_evidence_ids: MANAGED_NATIVE_VERIFICATION_EXAMPLE.native_observations.map(({ evidence_id: evidenceId }) => evidenceId),
+                    limits: MANAGED_NATIVE_VERIFICATION_EXAMPLE.limits,
+                },
+            },
+        ],
+    },
+    {
+        name: "import_managed_reconstruction",
+        ...toolContractMetadata("import_managed_reconstruction"),
+        description: "Import decompiler-produced managed reconstruction against authenticated inspect_managed_members Evidence. The workflow locks each method to artifact SHA-256, MVID, metadata token, signature hash, and normalized IL hash, records the decompiler identity and options, and marks C# or pseudocode as analyst inference rather than canonical byte observation.",
+        kind: "application",
+        inputSchema: managedReconstructionReferenceInputSchema,
+        outputSchema: reconstructionOutputSchema,
+        examples: [
+            {
+                title: "Import a decompiler reconstruction for one managed method",
+                input: {
+                    static_members_evidence_id: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE.static_members.evidence_id,
+                    decompiler: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE.decompiler,
+                    methods: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE.methods,
+                    notes: MANAGED_RECONSTRUCTION_IMPORT_EXAMPLE.notes,
+                },
+            },
+        ],
+    },
+    {
+        name: "plan_managed_runtime_correlation",
+        ...toolContractMetadata("plan_managed_runtime_correlation"),
+        description: "Prepare a separately authorized managed runtime-correlation admission plan from authenticated inspect_managed_members Evidence. The operation is default-disabled, requires the managed_runtime permission ceiling and grant, locks the exact artifact SHA-256, MVID, method signature, and normalized IL shape, distinguishes attach/load/debugger/reflection/instrumentation effects, and records that no target code was executed.",
+        kind: "application",
+        inputSchema: managedRuntimeCorrelationReferenceInputSchema,
+        outputSchema: runtimeOutputSchema,
+        examples: [
+            {
+                title: "Plan an exact-build managed runtime correlation",
+                input: {
+                    static_members_evidence_id: MANAGED_RUNTIME_CORRELATION_EXAMPLE.static_members.evidence_id,
+                    method: MANAGED_RUNTIME_CORRELATION_EXAMPLE.method,
+                    requested_effect: MANAGED_RUNTIME_CORRELATION_EXAMPLE.requested_effect,
+                    host: MANAGED_RUNTIME_CORRELATION_EXAMPLE.host,
+                    bounds: MANAGED_RUNTIME_CORRELATION_EXAMPLE.bounds,
+                },
+            },
+        ],
+    },
+    {
+        name: "project_managed_application_graph",
+        ...toolContractMetadata("project_managed_application_graph"),
+        description: "Project authenticated managed artifact, member, and native-boundary Evidence into the provider-neutral application graph without executing managed code, loading assemblies, or translating managed metadata tokens to native addresses. The graph preserves managed static observations as managed-specific nodes linked to source Evidence.",
+        kind: "application",
+        inputSchema: managedApplicationGraphReferenceInputSchema,
+        outputSchema: managedApplicationGraphOutputSchema,
+        examples: [
+            {
+                title: "Project static managed observations into an application graph",
+                input: {
+                    managed_members_evidence_id: MANAGED_APPLICATION_GRAPH_EXAMPLE.managed_members.evidence_id,
+                    limits: MANAGED_APPLICATION_GRAPH_EXAMPLE.limits,
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/nativeToolContracts.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { nativeOutputSchemas } from "./toolOutputSchemas.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
+import { toolContractMetadata } from "./toolEffects.js";
 const examples = {
     inspect_macho: {},
     inspect_signature: {},
@@ -14,16 +15,11 @@ const native = (name, description, inputSchema) => {
         throw new Error(`Missing native output schema for ${name}`);
     return {
         name,
+        ...toolContractMetadata(name),
         description,
         kind: "native-provider",
         inputSchema,
         outputSchema,
-        annotations: {
-            readOnlyHint: true,
-            destructiveHint: false,
-            idempotentHint: true,
-            openWorldHint: false,
-        },
         examples: [
             {
                 title: `Example ${name.replaceAll("_", " ")} request`,

package/dist/contracts/promptContracts.js

@@ -51,8 +51,12 @@ export const PROMPT_CONTRACTS = [
         },
         steps: [
             {
-                tools: ["binary_session", "open_binary"],
-                instruction: "Inspect provider availability and effects first. Open target_path only when no matching target is active.",
+                tools: [
+                    "binary_session",
+                    "open_binary",
+                    "analyze_javascript_application",
+                ],
+                instruction: "Inspect provider availability and effects first. For an approved JavaScript/Electron artifact, reconstruct its application graph without execution; otherwise open target_path only when no matching target is active.",
             },
             {
                 tools: ["list_documents", "set_current_document", "binary_overview"],
@@ -62,6 +66,10 @@ export const PROMPT_CONTRACTS = [
                 tools: ["search_strings", "search_procedures", "procedure_address"],
                 instruction: "Search in literal mode first, follow every continuation needed for the stated scope, and resolve selected procedures to canonical addresses.",
             },
+            {
+                tools: ["trace_application_feature"],
+                instruction: "When authenticated application-graph Evidence exists, trace a typed literal route, API, channel, module, string, or native export through a bounded cross-layer subgraph before native localization.",
+            },
             {
                 tools: [
                     "analyze_function",
@@ -95,6 +103,14 @@ export const PROMPT_CONTRACTS = [
                 tools: ["inventory_artifact"],
                 instruction: "Inventory each target independently before extraction. Follow nodes, occurrences, and edges to completion and retain every Evidence page for each manifest.",
             },
+            {
+                tools: [
+                    "analyze_javascript_application",
+                    "reconcile_javascript_runtime",
+                    "compare_application_versions",
+                ],
+                instruction: "For JavaScript/Electron versions, reconstruct each approved artifact independently, optionally reconcile separately retained passive runtime Evidence, then compare authenticated graphs with unique-only identity tiers. Keep ambiguous and incomplete matches unknown.",
+            },
             {
                 tools: ["export_evidence_bundle", "compare_artifacts"],
                 instruction: "Resolve any supplied manifest IDs to retained inventory Evidence, validate graph commitments, then compare the complete left and right Evidence page sets.",

package/dist/contracts/providerSelection.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+/** Stable provider identifier accepted at CLI, MCP, and environment boundaries. */
+export const analysisProviderIdSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[a-z][a-z0-9-]*$/u)
+    .refine((value) => value !== "auto", {
+    message: "auto is reserved for provider selection",
+});
+/** Explicit provider ID or the deterministic automatic-selection policy. */
+export const analysisProviderSelectorSchema = z.union([
+    z.literal("auto"),
+    analysisProviderIdSchema,
+]);
+/** Stable reasons a deep provider cannot participate in target selection. */
+export const PROVIDER_REJECTION_CODES = [
+    "not_configured",
+    "executable_missing",
+    "runtime_missing",
+    "unsupported_host",
+    "unsupported_version",
+    "target_kind_unsupported",
+    "target_format_unsupported",
+    "architecture_unsupported",
+    "open_options_invalid",
+    "version_unresolved",
+];

package/dist/contracts/sessionLifecycleInputs.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
+import { analysisProviderSelectorSchema } from "./providerSelection.js";
 /** Input contract for opening a target with an optional staged snapshot. */
 export const openBinaryInputSchema = z.object({
     path: z.string().min(1),
+    provider_id: analysisProviderSelectorSchema.optional(),
     snapshot_path: z.string().min(1).optional(),
 });
 /** Input contract for closing a target after an optional atomic snapshot. */

package/dist/contracts/toolContractExamples.js

@@ -1,4 +1,3 @@
-import { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "./processCaptureExample.js";
 import { UNKNOWN_CONTRACT_EXAMPLES } from "./unknownContractExamples.js";
 import { ARTIFACT_COMPARISON_EXAMPLE } from "./artifactComparisonExample.js";
 import { FUNCTION_COMPARISON_EXAMPLE } from "./functionComparisonExample.js";
@@ -38,32 +37,18 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     },
     compare_process_captures: {
         left_evidence_id: `ev_${"0".repeat(64)}`,
-        left: EMPTY_PROCESS_CAPTURE_EXAMPLE,
         right_evidence_id: `ev_${"1".repeat(64)}`,
-        right: EMPTY_PROCESS_CAPTURE_EXAMPLE,
     },
-    compare_artifacts: ARTIFACT_COMPARISON_EXAMPLE,
-    compare_functions: FUNCTION_COMPARISON_EXAMPLE,
+    compare_artifacts: {
+        left_evidence_ids: [ARTIFACT_COMPARISON_EXAMPLE.left.evidence_id],
+        right_evidence_ids: [ARTIFACT_COMPARISON_EXAMPLE.right.evidence_id],
+    },
+    compare_functions: {
+        left_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.left.evidence_id],
+        right_evidence_ids: [FUNCTION_COMPARISON_EXAMPLE.right.evidence_id],
+    },
     compare_bundles: {
-        left: {
-            bundle_version: 2,
-            artifacts: [],
-            providers: [],
-            environments: [],
-            scenarios: [],
-            captures: [],
-            unknowns: [],
-            records: [],
-        },
-        right: {
-            bundle_version: 2,
-            artifacts: [],
-            providers: [],
-            environments: [],
-            scenarios: [],
-            captures: [],
-            unknowns: [],
-            records: [],
-        },
+        left_bundle_path: "/approved/left-evidence.json",
+        right_bundle_path: "/approved/right-evidence.json",
     },
 };

package/dist/contracts/toolContracts.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { processCaptureSchema, processScenarioSchema, } from "../domain/processCapture.js";
+import { processScenarioSchema } from "../domain/processCapture.js";
 import { recordUnknownInputSchema, updateUnknownInputSchema, } from "../domain/residualUnknown.js";
 import { artifactComparisonInputSchema } from "../domain/artifactComparison.js";
 import { functionComparisonInputSchema } from "../domain/functionComparison.js";
@@ -14,11 +14,17 @@ import { enhancedOutputSchemas, officialOutputSchemas, requireOutputSchema, sess
 import { TOOL_EXAMPLE_OVERRIDES } from "./toolContractExamples.js";
 import { NATIVE_TOOL_CONTRACTS } from "./nativeToolContracts.js";
 import { ARTIFACT_TOOL_CONTRACTS } from "./artifactToolContracts.js";
+import { MANAGED_TOOL_CONTRACTS } from "./managedToolContracts.js";
+import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "./managedWorkflowToolContracts.js";
 import { BROWSER_TOOL_CONTRACTS } from "./browserToolContracts.js";
 import { ELECTRON_TOOL_CONTRACTS } from "./electronToolContracts.js";
+import { APPLICATION_TOOL_CONTRACTS } from "./applicationToolContracts.js";
 import { closeBinaryInputSchema, openBinaryInputSchema, } from "./sessionLifecycleInputs.js";
+import { toolContractMetadata } from "./toolEffects.js";
 const document = z.string().optional().describe("The document name");
-const address = z.string().describe("A Hopper address");
+const address = z
+    .string()
+    .describe("A provider-normalized address; default memory uses 0x-prefixed hexadecimal");
 const optionalAddress = address.optional();
 const procedure = z.string().describe("The procedure name or address");
 const searchPattern = z
@@ -52,23 +58,6 @@ const examplesFor = (name, inputSchema) => {
         },
     ];
 };
-const annotations = (name, kind) => ({
-    readOnlyHint: (kind === "enhanced" && name !== "trace_feature") ||
-        name === "binary_session" ||
-        name === "list_unknowns" ||
-        name === "verify_unknown_resolution",
-    destructiveHint: name === "export_evidence_bundle" ||
-        name === "close_binary" ||
-        name === "unset_bookmark" ||
-        name === "set_address_name" ||
-        name === "set_addresses_names" ||
-        name === "set_comment" ||
-        name === "set_inline_comment",
-    idempotentHint: name !== "close_binary" &&
-        name !== "record_unknown" &&
-        name !== "update_unknown",
-    openWorldHint: name === "capture_process_scenario",
-});
 const official = (name, description, inputSchema) => {
     const trackedInputSchema = inputSchema.extend({
         unknown_registry_approved: z
@@ -78,35 +67,35 @@ const official = (name, description, inputSchema) => {
     });
     return {
         name,
+        ...toolContractMetadata(name),
         description,
         kind: "official-proxy",
         inputSchema: trackedInputSchema,
         outputSchema: requireOutputSchema(officialOutputSchemas, name),
-        annotations: annotations(name, "official-proxy"),
         examples: examplesFor(name, trackedInputSchema),
     };
 };
 const enhanced = (name, description, inputSchema) => ({
     name,
+    ...toolContractMetadata(name),
     description,
     kind: "enhanced",
     inputSchema,
     outputSchema: requireOutputSchema(enhancedOutputSchemas, name),
-    annotations: annotations(name, "enhanced"),
     examples: examplesFor(name, inputSchema),
 });
 const session = (name, description, inputSchema) => ({
     name,
+    ...toolContractMetadata(name),
     description,
     kind: "session",
     inputSchema,
     outputSchema: requireOutputSchema(sessionOutputSchemas, name),
-    annotations: annotations(name, "session"),
     examples: examplesFor(name, inputSchema),
 });
 /** Bridge operations exposed without additional application composition. */
 export const OFFICIAL_TOOL_CONTRACTS = [
-    official("address_name", "Resolve the analyzed name at a code or data address, defaulting to Hopper's current cursor. Use before following a symbol into xrefs; null means Hopper has no name at that address.", z.object({ document, address: optionalAddress })),
+    official("address_name", "Resolve the primary analyzed name at a code or data address. Headless providers require an explicit address; GUI providers may default to their current cursor. Null means the provider has no primary name at that address.", z.object({ document, address: optionalAddress })),
     official("comment", "Read the regular analysis comment at an address, defaulting to the current cursor. This is read-only and returns null when no comment exists; use set_comment to persist a finding.", z.object({ document, address: optionalAddress })),
     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. Use procedure_info or analyze_function next; this depends on GUI cursor state and is not an exhaustive lookup.", z.object({ document })),
@@ -114,19 +103,19 @@ export const OFFICIAL_TOOL_CONTRACTS = [
     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("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_documents", "List all Hopper documents visible to the bridge. Use before set_current_document when a provider session contains multiple documents.", z.object({})),
-    official("list_names", "Page through analyzed names as address/value pairs. Results are bounded by offset and limit; follow next_offset until has_more is false before claiming exhaustive symbol coverage.", z.object({ document, address: optionalAddress, ...pagination })),
-    official("list_procedures", "Page through analyzed procedures as address/value pairs. Wait for Hopper analysis first, then follow next_offset for exhaustive coverage; use returned addresses with analyze_function or procedure_pseudo_code.", z.object({ document, ...pagination })),
-    official("list_segments", "List all segments and sections in the selected document. Hopper's public API does not expose permissions, so writable and executable are null with explicit capability metadata.", z.object({ document })),
-    official("list_strings", "Page through analyzed strings, or filter to one address, as address/value pairs. Follow next_offset for exhaustive results and use xrefs on interesting string addresses.", z.object({ document, address: optionalAddress, ...pagination })),
+    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", "Page through analyzed memory and external symbols as address/value pairs. Provider metadata distinguishes Ghidra primary, dynamic, external, type, and source facts when available; follow next_offset before claiming exhaustive coverage.", z.object({ document, address: optionalAddress, ...pagination })),
+    official("list_procedures", "Page through analyzed procedures as address/value pairs after provider analysis. Ghidra metadata distinguishes thunks and external functions; follow next_offset for exhaustive coverage and use returned addresses in later function operations.", z.object({ document, ...pagination })),
+    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", "Page through provider-defined strings, or filter to one address, as address/value pairs. Ghidra reports charset, missing-terminator status, byte length, and explicit value truncation; follow next_offset for exhaustive results.", z.object({ document, address: optionalAddress, ...pagination })),
     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("procedure_address", "Resolve a procedure symbol name or hexadecimal address to its entry address. Use this to canonicalize user-supplied identifiers before xrefs, assembly, or decompilation.", z.object({ procedure, document })),
+    official("procedure_address", "Resolve an unambiguous procedure symbol name or provider-normalized address to its canonical entry address. External address spaces remain explicit; use the result before xrefs, assembly, or decompilation.", 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 Hopper's analyzed direct callees for one procedure identified by symbol or address. Indirect calls may be absent; use analyze_function and xrefs to corroborate the call path.", z.object({ procedure, document })),
-    official("procedure_callers", "Return Hopper's analyzed direct callers for one procedure identified by symbol or address. Results reflect completed static analysis and may omit indirect references.", 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 bounded metadata for one procedure identified by symbol or address: entrypoint, signature, locals, size, and block count. Follow with decompilation or assembly for behavior.", z.object({ procedure, document })),
-    official("procedure_references", "Return a bounded set of raw incoming or outgoing reference edges for one procedure. Endpoint procedures are resolved only when Hopper reports containment; reference kinds remain explicitly unavailable.", z.object({
+    official("procedure_references", "Return a bounded set of raw incoming or outgoing reference edges 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({
         procedure,
         direction: z.enum(["incoming", "outgoing"]).default("outgoing"),
         offset: z.number().int().min(0).default(0),
@@ -134,10 +123,10 @@ export const OFFICIAL_TOOL_CONTRACTS = [
         max_instructions: z.number().int().min(1).max(5000).default(500),
         document,
     })),
-    official("procedure_pseudo_code", "Decompile one analyzed procedure by symbol name or hexadecimal address. Returns Hopper pseudocode, not original source, 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 xref source or interior instruction, to its Hopper-analyzed containing procedure. A negative result includes an explicit reason and is not guessed from nearby symbols.", z.object({ address, document })),
-    official("search_procedures", "Search analyzed procedure names using literal matching by default or regex opt-in. Regex rejects unsupported constructs, more than 10,000 static backtracking paths, candidates over 4,096 characters, and searches over 1,000,000 work units. Results are deterministic and offset-paginated.", z.object(searchInput)),
-    official("search_strings", "Search analyzed strings using literal matching by default or regex opt-in. Regex rejects unsupported constructs, more than 10,000 static backtracking paths, candidates over 4,096 characters, and searches over 1,000,000 work units. Results are deterministic, offset-paginated, and explicitly truncated.", z.object(searchInput)),
+    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 analyzed procedure names using literal matching by default or regex opt-in. Ghidra bounds literal work and rejects regex constructs, paths, candidates, or cumulative work outside its finite budgets. Results are deterministic and offset-paginated.", z.object(searchInput)),
+    official("search_strings", "Search analyzed strings using literal matching by default or regex opt-in. Ghidra bounds literal work and rejects regex constructs, paths, candidates, or cumulative work outside its finite budgets. Results are deterministic, offset-paginated, and explicitly truncated.", z.object(searchInput)),
     official("set_address_name", "Assign an analyst name to one hexadecimal address and report Hopper's boolean result. This mutates analysis metadata; read it back with address_name before relying on it.", z.object({ address, name: z.string(), document })),
     official("set_addresses_names", "Assign analyst names to an address/name map and return per-address success booleans. This mutates analysis metadata; use for bounded batches and 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. This mutates navigation metadata; verify with list_bookmarks and do not treat bookmarks as binary evidence.", z.object({ address, name: z.string().optional(), document })),
@@ -153,11 +142,11 @@ export const ENHANCED_TOOL_CONTRACTS = [
     enhanced("get_objc_classes", "Discover and deduplicate Objective-C class labels after exhaustively paging names, optionally filtering by literal substring. Returns at most 100 classes; inspect matching metadata and references next.", enhancedInputSchemas.get_objc_classes),
     enhanced("get_objc_protocols", "Discover and deduplicate Objective-C and Swift protocol labels after exhaustively paging names. Returns at most 100 entries; use xrefs or analyze_function to connect a protocol to implementations.", enhancedInputSchemas.get_objc_protocols),
     enhanced("batch_decompile", "Decompile up to 20 explicit procedure symbols or addresses concurrently. Returns ordered per-item ok/error variants and aggregate counts; use analyze_function for a richer single-function dossier.", enhancedInputSchemas.batch_decompile),
-    enhanced("get_call_graph", "Traverse Hopper's caller or callee relationships from one symbol or address for at most five levels. Every node has an ok/error status and failures use safe typed projections; indirect calls may be missing and results are not a whole-program CFG.", enhancedInputSchemas.get_call_graph),
+    enhanced("get_call_graph", "Traverse the bound provider's caller or callee relationships from one symbol or address for at most five levels. Every node has an ok/error status and 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 exhaustively paged procedure names into Swift classes, structs, enums, protocols, extensions, and other symbols. Scans at most 5,000 names and returns at most 50 entries per category.", enhancedInputSchemas.analyze_swift_types),
-    enhanced("find_xrefs_to_name", "Resolve an exact name through Hopper's exhaustively paged name inventory and return a resolved or unresolved result. Unresolved names use the stable name_not_found reason; xrefs remain untyped.", enhancedInputSchemas.find_xrefs_to_name),
+    enhanced("find_xrefs_to_name", "Resolve an exact name through the bound provider's exhaustively paged name inventory and return a resolved or unresolved result. Unresolved names use the stable name_not_found reason; this compact xref workflow returns address-only projections.", enhancedInputSchemas.find_xrefs_to_name),
     enhanced("binary_overview", "Use immediately after opening a target to summarize document, exhaustive procedure/string counts, and a bounded segment sample. detail controls segment fields and limit controls only the returned segment sample.", enhancedInputSchemas.binary_overview),
-    enhanced("analyze_function", "Preferred bounded analysis for one procedure symbol or address. Returns identity, pseudocode, optional assembly, comments, calls, incoming references, and blocks; unsupported outgoing references and CFG edges carry explicit unavailable metadata.", enhancedInputSchemas.analyze_function),
+    enhanced("analyze_function", "Preferred bounded analysis for one procedure symbol or address. Returns identity, provider-specific pseudocode, optional assembly, comments, calls, typed-or-explicitly-unavailable references, referenced strings/names, and local CFG blocks with exact truncation metadata.", enhancedInputSchemas.analyze_function),
     enhanced("trace_feature", "Trace a bounded literal feature query through matching strings and procedures, xrefs, and truthful containing-procedure resolution. Returns the operation budget, truncation, and residual unknowns; unknown_registry_approved: true records them durably without inferring reference kinds.", enhancedInputSchemas.trace_feature),
 ];
 /** Caller observations used to compare a live server with expected identity. */
@@ -169,28 +158,46 @@ export const binarySessionInputSchema = z.object({
         .optional(),
     expected_server_path: z.string().min(1).optional(),
 });
+/** Session-owned Evidence bundle export options. */
+export const exportEvidenceBundleInputSchema = z.strictObject({
+    path: z.string().min(1).optional(),
+    overwrite: z.boolean().default(false),
+});
+/** Session-owned Evidence bundle import options. */
+export const importEvidenceBundleInputSchema = z.strictObject({
+    path: z.string().min(1),
+});
+/** Evidence references for deterministic process comparison. */
+export const processComparisonInputSchema = z.strictObject({
+    left_evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
+    right_evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
+    max_capture_age_ms: z.number().int().nonnegative().optional(),
+    unknown_registry_approved: z
+        .literal(true)
+        .optional()
+        .describe("Explicit approval to record capture disagreement durably"),
+});
+/** Residual-unknown list filters. */
+export const listUnknownsInputSchema = z.strictObject({
+    status: z
+        .enum(["open", "investigating", "blocked", "contradicted", "resolved"])
+        .optional(),
+    severity: z.enum(["low", "medium", "high", "critical"]).optional(),
+    domain: z.string().trim().min(1).max(100).optional(),
+});
+/** Exact residual-unknown identity to revalidate. */
+export const verifyUnknownResolutionInputSchema = z.strictObject({
+    unknown_id: z.string().regex(/^unk_[a-f0-9]{64}$/u),
+});
 /** 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 Hopper database after validation. An optional provider-neutral snapshot is imported atomically and must match the binary digest, format, and architecture exactly; provider resources may still start before an MCP cache replay.", openBinaryInputSchema),
+    session("open_binary", "Open a local executable, application bundle, archive, JavaScript, source map, plist, or analysis database after validation. 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 snapshot v2 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, then close the active target and every provider resource started for it. Snapshot files require an operator-approved root and explicit overwrite; a failed save leaves the session open so cached analysis is not lost.", closeBinaryInputSchema),
-    session("binary_session", "Report provider identity, deterministic capability descriptors, and whether a target is open; open targets include canonical path, format, and kind. Use availability, effects, limits, and limitations before selecting analysis operations.", binarySessionInputSchema),
-    session("export_evidence_bundle", "Return the session's deterministic Evidence v2 bundle, or atomically write it beneath an operator-approved root. Existing files require overwrite: true; records and manifests use canonical byte-stable ordering.", z.object({
-        path: z.string().min(1).optional(),
-        overwrite: z.boolean().default(false),
-    })),
-    session("import_evidence_bundle", "Read a bounded local JSON bundle beneath an operator-approved root, validate every Evidence v2 ID and canonical manifest, then atomically merge it. Imported content is data only and is never executed.", z.object({ path: z.string().min(1) })),
+    session("binary_session", "Report deterministic deep-provider candidates, host availability, target support, the immutable active binding/profile, capability descriptors, and whether a target is open. Candidate discovery never starts an analysis process; use rejection codes and local diagnostics before choosing provider_id.", binarySessionInputSchema),
+    session("export_evidence_bundle", "Return the session's deterministic Evidence v2 bundle, or atomically write it beneath an operator-approved root. Existing files require overwrite: true; records and manifests use canonical byte-stable ordering.", exportEvidenceBundleInputSchema),
+    session("import_evidence_bundle", "Read a bounded local JSON bundle beneath an operator-approved root, validate every Evidence v2 ID and canonical manifest, then atomically merge it. Imported content is data only and is never executed.", importEvidenceBundleInputSchema),
     session("capture_process_scenario", "Run one bounded process under a PTY using operator-approved executable and working roots. Produces Process Capture v4; legacy v3 captures cannot be upgraded and must be recaptured with this tool. Requires approved: true; unknown_registry_approved: true separately records capture residuals. Captures raw and xterm-rendered terminal frames, scripted interactions, lifecycle filesystem checkpoints, process ownership, declarative command shims, and loopback replay. Disabled unless operator policy enables it; not a security sandbox.", processScenarioSchema),
-    session("compare_process_captures", "Compare two compatible Process Capture v4 observations across terminal, interaction, exit, settlement, process, filesystem, command-shim, HTTP, and WebSocket evidence, returning the first bounded divergence. Process Capture v3 is unsupported and must be recaptured with capture_process_scenario. Missing or truncated observations are never treated as equivalent.", z.object({
-        left_evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
-        left: processCaptureSchema,
-        right_evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
-        right: processCaptureSchema,
-        max_capture_age_ms: z.number().int().nonnegative().optional(),
-        unknown_registry_approved: z
-            .literal(true)
-            .optional()
-            .describe("Explicit approval to record capture disagreement durably"),
-    })),
+    session("compare_process_captures", "Compare two compatible Process Capture v4 observations across terminal, interaction, exit, settlement, process, filesystem, command-shim, HTTP, and WebSocket evidence, returning the first bounded divergence. Process Capture v3 is unsupported and must be recaptured with capture_process_scenario. Missing or truncated observations are never treated as equivalent.", processComparisonInputSchema),
     session("compare_artifacts", "Compare two bounded sets of inventory_artifact Evidence pages by logical occurrence path, content identity, metadata, and graph relations. Pages must share and satisfy their graph commitment; every delta cites both sets, and gaps yield truncated or unknown, never equivalence.", artifactComparisonInputSchema),
     session("compare_functions", "Compare two explicit bounded sets of analyze_function Evidence pages 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),
     session("compare_bundles", "Compare two canonical Evidence v2 bundles by exact record membership, explicit one-to-one observation pairs, and complete residual-unknown revision histories. Missing bundle members describe omission only, never behavioral equivalence; output is digest-anchored and deterministically paginated.", bundleComparisonInputSchema),
@@ -198,16 +205,10 @@ export const SESSION_TOOL_CONTRACTS = [
     session("build_call_path", "Build bounded shortest-first direct-callee paths from explicit analyze_function Evidence groups using exact canonical addresses. Missing dossiers, incomplete callee pages, provider mixing, and depth frontiers remain unknown; every node and edge cites source Evidence.", callPathInputSchema),
     session("correlate_static_and_runtime", "Evaluate explicit caller-declared hypotheses 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.", 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 current residual-unknown heads in deterministic ID order, with optional exact status, severity, and domain filters. This is read-only; unresolved, contradicted, and non-truth dispositions remain distinct.", z.object({
-        status: z
-            .enum(["open", "investigating", "blocked", "contradicted", "resolved"])
-            .optional(),
-        severity: z.enum(["low", "medium", "high", "critical"]).optional(),
-        domain: z.string().trim().min(1).max(100).optional(),
-    })),
+    session("list_unknowns", "List current residual-unknown heads in deterministic ID order, with optional exact status, severity, and domain filters. 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. Requires approved: true, 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 approved: true and 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.", z.object({ unknown_id: z.string().regex(/^unk_[a-f0-9]{64}$/u) })),
+    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),
 ];
 /** Complete ordered public inventory used by registration and verification. */
 export const TOOL_CONTRACTS = [
@@ -215,7 +216,10 @@ export const TOOL_CONTRACTS = [
     ...ENHANCED_TOOL_CONTRACTS,
     ...NATIVE_TOOL_CONTRACTS,
     ...ARTIFACT_TOOL_CONTRACTS,
+    ...MANAGED_TOOL_CONTRACTS,
+    ...MANAGED_WORKFLOW_TOOL_CONTRACTS,
     ...BROWSER_TOOL_CONTRACTS,
     ...ELECTRON_TOOL_CONTRACTS,
+    ...APPLICATION_TOOL_CONTRACTS,
     ...SESSION_TOOL_CONTRACTS,
 ];