rea-agents 3.2.0 → 4.0.0

package/dist/contracts/managedWorkflowToolContracts.js

@@ -1,9 +1,8 @@
 import { z } from "zod";
 import { evidenceSchema } from "../domain/evidence.js";
 import { managedReconstructionImportInputSchema } from "../domain/managedReconstruction.js";
-import { managedRuntimeCorrelationInputSchema } from "../domain/managedRuntimeCorrelation.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 { 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";
 /** Inputs for comparing two managed observations carried inline. */
@@ -20,10 +19,6 @@ export const compareManagedMembersReferenceInputSchema = z
             message: "Managed member Evidence must be distinct",
         });
 });
-/** MCP reference for planning from one session-owned managed observation. */
-export const managedRuntimeCorrelationReferenceInputSchema = managedRuntimeCorrelationInputSchema.extend({
-    static_members: evidenceSchema,
-});
 /** Inline Evidence input for importing reconstruction. */
 export const managedReconstructionReferenceInputSchema = managedReconstructionImportInputSchema.extend({
     static_members: evidenceSchema,
@@ -56,14 +51,25 @@ export const managedNativeVerificationReferenceInputSchema = z
     }
 });
 const managedApplicationGraphReferenceFacts = {};
-/** Inline Evidence sources for managed application graph projection. */
-export const managedApplicationGraphReferenceInputSchema = z
-    .strictObject({
+const managedApplicationGraphReferenceShape = z.strictObject({
     ...managedApplicationGraphReferenceFacts,
     managed_artifact: evidenceSchema.optional(),
     managed_members: evidenceSchema.optional(),
     managed_native_boundaries: evidenceSchema.optional(),
-})
+});
+/** Inline Evidence sources for managed application graph projection. */
+export const managedApplicationGraphReferenceInputSchema = z
+    .union([
+    managedApplicationGraphReferenceShape.extend({
+        managed_artifact: evidenceSchema,
+    }),
+    managedApplicationGraphReferenceShape.extend({
+        managed_members: evidenceSchema,
+    }),
+    managedApplicationGraphReferenceShape.extend({
+        managed_native_boundaries: evidenceSchema,
+    }),
+])
     .superRefine((input, context) => {
     const ids = [
         input.managed_artifact?.evidence_id,
@@ -82,7 +88,6 @@ export const managedApplicationGraphReferenceInputSchema = z
         });
 });
 const comparisonOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "compare_managed_members");
-const runtimeOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "plan_managed_runtime_correlation");
 const reconstructionOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "import_managed_reconstruction");
 const nativeVerificationOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "verify_managed_native_boundaries");
 const managedApplicationGraphOutputSchema = requireOutputSchema(managedWorkflowOutputSchemas, "project_managed_application_graph");
@@ -141,26 +146,6 @@ export const MANAGED_WORKFLOW_TOOL_CONTRACTS = [
             },
         ],
     },
-    {
-        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 limited decoded-IL tuple hash, 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: MANAGED_RUNTIME_CORRELATION_EXAMPLE.static_members,
-                    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"),

package/dist/contracts/nativeToolContracts.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { nativeUiObservationInputSchema, nativeUiScenarioInputSchema, } from "../domain/nativeUiObservation.js";
 import { nativeOutputSchemas } from "./toolOutputSchemas.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { toolContractMetadata } from "./toolEffects.js";
@@ -8,6 +9,12 @@ const examples = {
     inspect_signature: {},
     inspect_plist: { path: "/Applications/Example.app/Contents/Info.plist" },
     list_architectures: {},
+    observe_native_ui: { pid: 123, window_id: 456 },
+    capture_native_ui_scenario: {
+        pid: 123,
+        window_id: 456,
+        steps: [{ kind: "wait", milliseconds: 100 }],
+    },
     demangle_swift: { symbols: ["$s4Test3fooyyF"] },
 };
 const native = (name, description, inputSchema) => {
@@ -31,6 +38,8 @@ const native = (name, description, inputSchema) => {
 };
 /** Provider-neutral semantic operations backed initially by macOS utilities. */
 export const NATIVE_TOOL_CONTRACTS = [
+    native("observe_native_ui", "Observe an already-running native app by PID and window ID, bound to the active Mach-O target. Captures a bounded accessibility tree and selected-window screenshot; OS permission denial fails without broad capture or target launch.", nativeUiObservationInputSchema),
+    native("capture_native_ui_scenario", "Run selected-element press, increment/decrement scroll, AXValue text entry and bounded wait steps in one exact native app window. Returns ordered before/after captures and action/capture failures. Actions can change app data, network activity and persistent state; application state is left as-is and restoration is not attempted.", nativeUiScenarioInputSchema),
     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({

package/dist/contracts/promptContracts.js

@@ -187,7 +187,7 @@ export const PROMPT_CONTRACTS = [
             },
             {
                 tools: ["capture_process_scenario", "correlate_static_and_runtime"],
-                instruction: "Reuse a supplied capture when relevant; otherwise capture when enabled and authorized. Correlate through explicit hypotheses rather than timing or name coincidence.",
+                instruction: "Reuse a supplied capture when relevant; otherwise capture a bounded runtime reproduction when it can distinguish competing explanations. Correlate through explicit hypotheses rather than timing or name coincidence.",
             },
             {
                 tools: ["record_unknown"],
@@ -227,18 +227,18 @@ export const PROMPT_CONTRACTS = [
     {
         name: "prepare_bounded_process_capture",
         title: "Prepare a bounded process capture",
-        description: "Design an approval-gated process capture scenario with exact executable, filesystem, environment, network, replay, timeout, and cleanup boundaries.",
-        objective: "Prepare and, after authorization, run a controlled process experiment that can answer the stated behavioral question.",
+        description: "Choose a command, inputs, observations, and stopping conditions for a process capture that answers the behavioral question.",
+        objective: "Run a caller-selected process experiment that can answer the stated behavioral question.",
         arguments: {
             behavior_question: required("Behavioral question the capture must answer and stopping condition"),
-            executable: required("Absolute executable path requested for the scenario"),
-            working_directory: required("Absolute working directory requested for the scenario"),
+            executable: required("Command name or executable path requested for the scenario"),
+            working_directory: required("Working directory requested for the scenario"),
             prior_capture_evidence_id: optional("Retained process capture Evidence to compare or refine", "capture"),
         },
         steps: [
             {
                 tools: ["capture_process_scenario"],
-                instruction: "Present the requested scenario and explain the actual authority, runtime constraints, and cleanup behavior. Run only when operator policy authorizes it.",
+                instruction: "Run the caller-provided scenario. Explain command lookup, effective working directory, inherited environment, optional filesystem observations, and that the target runs with the current user's permissions.",
             },
             {
                 tools: ["compare_process_captures"],

package/dist/contracts/sessionToolSchemas.js

@@ -9,12 +9,12 @@ import { processScenarioSchema } from "../domain/processCapture.js";
 import { processTraceSpecificationSchema } from "../domain/processTraceComparison.js";
 import { recordUnknownInputSchema } from "../domain/residualUnknown.js";
 import { reconstructionVerificationInputSchema } from "../domain/reconstructionVerification.js";
-import { replayMachineRunInputSchema } from "../domain/replayMachineRun.js";
 import { staticRuntimeCorrelationInputSchema } from "../domain/staticRuntimeCorrelation.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({});
 /** Optional document selection for volatile navigation context. */
@@ -47,6 +47,6 @@ export const listUnknownsInputSchema = z.strictObject({
 });
 /** Exact residual-unknown identity to revalidate. */
 export const verifyUnknownResolutionInputSchema = z.strictObject({
-    unknown_id: z.string().regex(/^unk_[a-f0-9]{64}$/u),
+    unknown_id: prefixedDigestSchema("unk"),
 });
-export { artifactComparisonInputSchema, binarySessionInputSchema, bundleComparisonInputSchema, callPathInputSchema, changedBehaviorInputSchema, closeBinaryInputSchema, functionComparisonInputSchema, jsonValueSchema, openBinaryInputSchema, processScenarioSchema, reconstructionVerificationInputSchema, recordUnknownInputSchema, replayMachineRunInputSchema, staticRuntimeCorrelationInputSchema, updateUnknownInputSchema, };
+export { artifactComparisonInputSchema, binarySessionInputSchema, bundleComparisonInputSchema, callPathInputSchema, changedBehaviorInputSchema, closeBinaryInputSchema, functionComparisonInputSchema, jsonValueSchema, openBinaryInputSchema, processScenarioSchema, reconstructionVerificationInputSchema, recordUnknownInputSchema, staticRuntimeCorrelationInputSchema, updateUnknownInputSchema, };

package/dist/contracts/toolContractExamples.js

@@ -2,7 +2,6 @@ import { UNKNOWN_CONTRACT_EXAMPLES } from "./unknownContractExamples.js";
 import { ARTIFACT_COMPARISON_EXAMPLE } from "./artifactComparisonExample.js";
 import { FUNCTION_COMPARISON_EXAMPLE } from "./functionComparisonExample.js";
 import { INVESTIGATION_EXAMPLES, PROCESS_CAPTURE_REFERENCE, PROCESS_CAPTURE_RECONSTRUCTION, } from "./investigationExamples.js";
-import { REPLAY_MACHINE_RUN_EXAMPLE } from "./replayMachineExample.js";
 /** Canonical examples for contracts whose required inputs have no defaults. */
 export const TOOL_EXAMPLE_OVERRIDES = {
     ...UNKNOWN_CONTRACT_EXAMPLES,
@@ -13,6 +12,10 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     procedure_callees: { procedure: "main" },
     procedure_callers: { procedure: "main" },
     procedure_info: { procedure: "main" },
+    trace_native_values: { procedure: "0x1000" },
+    inspect_native_data_type: { type: "/MyStruct" },
+    inspect_native_instruction: { address: "0x1000" },
+    resolve_native_call_targets: { address: "0x1000" },
     read_function_instructions: { procedure: "main" },
     read_bytes: { address: "0x1000", length: 16 },
     address_to_file_offset: { address: "0x1000" },
@@ -34,7 +37,6 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     analyze_swift_types: { category: "classes", pattern: "Account" },
     inspect_native_api: { procedure: "main" },
     trace_feature: { query: "license" },
-    find_code_for_string: { query: "authorization failed" },
     trace_call_path: { start: "0x1000", goal: "0x1100" },
     trace_native_ui_action: { action: "buildTapped:" },
     open_binary: { path: "/tmp/fixture" },
@@ -45,7 +47,6 @@ export const TOOL_EXAMPLE_OVERRIDES = {
         executable: "/usr/bin/true",
         working_directory: "/tmp",
     },
-    run_replay_machine: REPLAY_MACHINE_RUN_EXAMPLE,
     compare_process_captures: {
         left: PROCESS_CAPTURE_REFERENCE,
         right: PROCESS_CAPTURE_RECONSTRUCTION,

package/dist/contracts/toolContracts.js

@@ -9,9 +9,11 @@ import { BROWSER_PROVIDER_TOOL_CONTRACTS } from "./browserProviderToolContracts.
 import { ELECTRON_TOOL_CONTRACTS } from "./electronToolContracts.js";
 import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "./javascriptRuntimeObservationToolContracts.js";
 import { APPLICATION_TOOL_CONTRACTS } from "./applicationToolContracts.js";
-import { addressContextInputSchema, artifactComparisonInputSchema, binarySessionInputSchema, bundleComparisonInputSchema, callPathInputSchema, changedBehaviorInputSchema, closeBinaryInputSchema, functionComparisonInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, navigationContextInputSchema, openBinaryInputSchema, processComparisonInputSchema, processScenarioSchema, reconstructionVerificationInputSchema, recordUnknownInputSchema, replayMachineRunInputSchema, getEvidenceBundleInputSchema, staticRuntimeCorrelationInputSchema, updateUnknownInputSchema, verifyUnknownResolutionInputSchema, } from "./sessionToolSchemas.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 { address, document, examplesFor, optionalAddress, procedure, } from "./toolContractHelpers.js";
 import { toolContractMetadata } from "./toolEffects.js";
+import { nativeDataTypeInputSchema } from "../domain/nativeDataType.js";
+import { nativeInstructionInputSchema } from "../domain/nativeInstruction.js";
 import { functionInstructionInputSchema } from "./functionInstructionContract.js";
 import { HOPPER_MEMORY_TOOL_DEFINITIONS } from "./hopperMemoryContracts.js";
 import { analysisSearchInput } from "./analysisSearchContract.js";
@@ -46,6 +48,9 @@ const session = (name, description, inputSchema) => ({
 });
 /** Bridge operations exposed without additional application composition. */
 export const OFFICIAL_TOOL_CONTRACTS = [
+    official("inspect_native_data_type", "Inspect one recovered type by exact database category path or defined typed data address. Returns observed size, alignment, packing, fields, bitfields, enum values, and child type identities; source-level authority and flexible-tail semantics remain unknown unless substantiated.", nativeDataTypeInputSchema),
+    official("inspect_native_instruction", "Inspect one exact instruction address: decoded bytes, mnemonic, ordered operand tokens, flow and typed references. Memory addressing decomposition is unavailable when the provider supplies only tokens. Data, interior instruction addresses and undecodable bytes are distinct outcomes.", nativeInstructionInputSchema),
+    official("resolve_native_call_targets", "Resolve one explicit static call site using typed provider call references. Preserves ambiguous targets as candidates and unresolved computed calls as unknown; does not execute code or traverse a call graph.", nativeInstructionInputSchema),
     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 })),
@@ -65,7 +70,7 @@ export const OFFICIAL_TOOL_CONTRACTS = [
     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, and block count.", 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("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({
@@ -84,7 +89,7 @@ export const OFFICIAL_TOOL_CONTRACTS = [
     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("xrefs", "Return analyzed references to a code or data address, defaulting to the current cursor. Use to connect strings, globals, selectors, and functions; bare addresses are untyped and indirect references may be incomplete.", z.object({ document, address: optionalAddress })),
+    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 })),
 ];
 /** Workflow tools composed from one or more provider operations. */
 export const ENHANCED_TOOL_CONTRACTS = [
@@ -98,9 +103,9 @@ export const ENHANCED_TOOL_CONTRACTS = [
     enhanced("binary_overview", "Return native-binary metadata, every segment with its length, and exhaustive procedure/string counts. Use search_procedures, list_procedures, or analyze_function directly when you already know which procedure to inspect.", enhancedInputSchemas.binary_overview),
     ...FUNCTION_WORKFLOW_TOOL_CONTRACTS,
     enhanced("trace_feature", "Trace a literal feature query through every matching string and procedure, their xrefs, and truthful containing-procedure resolution. Returns observations, operation count, and residual unknowns without inferring reference kinds.", enhancedInputSchemas.trace_feature),
-    enhanced("find_code_for_string", "Resolve one literal string query across analyzed string entries, xrefs, and truthful containing-procedure candidates. Returns observations, operation count, and residual unknowns; it never infers reference kinds or runtime reachability.", enhancedInputSchemas.find_code_for_string),
     enhanced("trace_call_path", "Trace direct callers or callees from one exact procedure address until the graph is exhausted or the optional goal is reached. Returns visited nodes, direct-call edges, a shortest traversal path, provider failures, and residual unknowns; unresolved indirect calls remain unknown.", enhancedInputSchemas.trace_call_path),
-    enhanced("trace_native_ui_action", "Trace one unique compiled Interface Builder action selector or object ID through its authored UI connections to symbolized Objective-C handlers and bounded direct callees. REA decodes the active app bundle and reads the selected provider's symbol inventory itself. Authored connections, statically matched handlers, resolved direct calls, and unresolved dynamic dispatch remain distinct; runtime reachability and cross-function value flow are not claimed.", enhancedInputSchemas.trace_native_ui_action),
+    enhanced("trace_native_ui_action", "Trace one unique compiled UI action, object ID, native symbol or exact function address through authored connections, encoded or symbolized Objective-C handlers, and bounded static call references. Typed direct and resolved indirect calls, ambiguous candidates, inferred untyped provider callees, and targetless sites remain distinct. Runtime reachability is unknown; use trace_native_values for recovered value dependencies.", enhancedInputSchemas.trace_native_ui_action),
+    enhanced("trace_native_values", "Trace a bounded static dependency graph from one explicit native procedure. Includes high-p-code def-use, constants, operators, memory and branch operations, resolved call edges, and derived argument/parameter and return/output bindings. Missing bindings, alias semantics, persistent state and RNG roles remain unknown. Budgets bound depth, decompilations, graph size and payloads; nodes are paginated.", enhancedInputSchemas.trace_native_values),
 ];
 /** Session-owned Evidence bundle export options. */
 export const exportEvidenceBundleInputSchema = z.strictObject({
@@ -114,7 +119,7 @@ export const SESSION_TOOL_CONTRACTS = [
     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 bounded process under a PTY using operator-approved executable and working roots. Produces process capture Evidence and records residual unknowns linked to that Evidence. 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("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. 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("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),
@@ -127,7 +132,6 @@ export const SESSION_TOOL_CONTRACTS = [
     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("run_replay_machine", "Evaluate ordered HTTP and WebSocket events directly against one validated finite replay machine without opening sockets or launching a target. Returns every decision, a capture-value-free transition journal, one redacted action table entry per used transition, captured aliases, final state, and exact configured and consumed limits.", replayMachineRunInputSchema),
     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_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),
@@ -146,3 +150,10 @@ export const TOOL_CONTRACTS = [
     ...APPLICATION_TOOL_CONTRACTS,
     ...SESSION_TOOL_CONTRACTS,
 ];
+/** Resolve a public contract by name while retaining its exact schema types. */
+export const toolContract = (name) => {
+    const contract = TOOL_CONTRACTS.find((candidate) => candidate.name === name);
+    if (contract === undefined)
+        throw new Error(`Missing tool contract: ${name}`);
+    return contract;
+};

package/dist/contracts/toolEffects.js

@@ -20,6 +20,7 @@ const sessionEvidence = effects({ mutatesSession: true });
 export const TOOL_EFFECTS = {
     inspect_native_dispatch_metadata: evidence,
     trace_native_ui_action: evidence,
+    trace_native_values: evidence,
     address_name: evidence,
     comment: evidence,
     current_address: evidence,
@@ -41,6 +42,9 @@ export const TOOL_EFFECTS = {
     procedure_callers: evidence,
     procedure_info: evidence,
     read_function_instructions: evidence,
+    inspect_native_instruction: evidence,
+    inspect_native_data_type: evidence,
+    resolve_native_call_targets: evidence,
     read_bytes: evidence,
     address_to_file_offset: evidence,
     procedure_references: evidence,
@@ -70,32 +74,56 @@ export const TOOL_EFFECTS = {
     analyze_function: evidence,
     inspect_native_api: effects({ mutatesSession: true, idempotent: false }),
     trace_feature: effects({ mutatesSession: true, idempotent: false }),
-    find_code_for_string: effects({ mutatesSession: true, idempotent: false }),
     trace_call_path: effects({ mutatesSession: true, idempotent: false }),
+    observe_native_ui: effects({
+        mutatesSession: true,
+        launchesProcess: true,
+        writesFilesystem: true,
+    }),
+    capture_native_ui_scenario: effects({
+        writesFilesystem: true,
+        mutatesTarget: true,
+        mutatesSession: true,
+        launchesProcess: true,
+        accessesNetwork: true,
+        changesUiState: true,
+        mayDiscardData: true,
+        idempotent: false,
+    }),
     inspect_macho: nativeEvidence,
     inspect_signature: nativeEvidence,
     inspect_plist: nativeEvidence,
     list_architectures: nativeEvidence,
     demangle_swift: nativeEvidence,
-    inspect_artifact: evidence,
-    extract_artifact: effects({ mutatesSession: true, writesFilesystem: true }),
+    inspect_artifact: effects({
+        mutatesSession: true,
+        launchesProcess: true,
+        writesFilesystem: true,
+    }),
+    extract_artifact: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+        idempotent: false,
+    }),
     decode_interface_builder: evidence,
+    inspect_asset_catalog: nativeEvidence,
+    inspect_keyed_archive: evidence,
     inspect_managed_artifact: evidence,
     inspect_managed_members: evidence,
     inspect_managed_native_boundaries: evidence,
     compare_managed_members: sessionEvidence,
     verify_managed_native_boundaries: sessionEvidence,
     import_managed_reconstruction: sessionEvidence,
-    plan_managed_runtime_correlation: sessionEvidence,
     project_managed_application_graph: sessionEvidence,
     list_browser_targets: browserEvidence,
     inspect_web_page: browserEvidence,
     analyze_web_bundle: browserEvidence,
     observe_web_session: browserEvidence,
     discover_webmcp_tools: browserEvidence,
-    compare_web_captures: browserEvidence,
+    compare_web_captures: sessionEvidence,
     capture_web_screenshot: browserEvidence,
-    compare_web_screenshots: browserEvidence,
+    compare_web_screenshots: sessionEvidence,
     capture_browser_scenario: effects({
         mutatesTarget: true,
         mutatesSession: true,
@@ -128,21 +156,6 @@ export const TOOL_EFFECTS = {
     compare_source_to_bundle: evidence,
     compare_javascript_export_shapes: evidence,
     build_reconstruction_obligation_ledger: evidence,
-    run_replay_machine: effects(),
-    run_controlled_replay: effects({
-        mutatesSession: true,
-        writesFilesystem: true,
-        launchesProcess: true,
-    }),
-    prepare_node_characterization: effects({
-        mutatesSession: true,
-        launchesProcess: true,
-    }),
-    execute_node_characterization: effects({
-        mutatesSession: true,
-        writesFilesystem: true,
-        launchesProcess: true,
-    }),
     evaluate_reconstruction_coverage: effects(),
     open_binary: effects({ mutatesSession: true, launchesProcess: true }),
     close_binary: effects({

package/dist/contracts/toolOutputSchemaGroups.js

@@ -1,4 +1,8 @@
 import { z } from "zod";
+import { nativeUiResultSchema } from "../domain/nativeUiObservation.js";
+import { nativeValueTraceSchema } from "../domain/nativeValueTrace.js";
+import { nativeDataTypeSchema } from "../domain/nativeDataType.js";
+import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/nativeInstruction.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { residualUnknownSchema } from "../domain/residualUnknown.js";
 import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
@@ -9,11 +13,12 @@ import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSig
 import { artifactExtractionResultSchema } from "../domain/artifactGraph.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 import { interfaceBuilderAnalysisSchema } from "../domain/interfaceBuilderGraph.js";
+import { keyedArchiveResultSchema } from "../domain/keyedArchive.js";
+import { appleAssetCatalogResultSchema } from "../domain/appleAssetCatalog.js";
 import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "../domain/managedArtifact.js";
 import { managedMemberComparisonResultSchema } from "../domain/managedMemberComparison.js";
 import { managedNativeVerificationResultSchema } from "../domain/managedNativeVerification.js";
 import { managedReconstructionImportResultSchema } from "../domain/managedReconstruction.js";
-import { managedRuntimeCorrelationResultSchema } from "../domain/managedRuntimeCorrelation.js";
 import { managedApplicationGraphResultSchema } from "../domain/managedApplicationGraph.js";
 import { artifactComparisonResultSchema } from "../domain/artifactComparison.js";
 import { functionComparisonResultSchema } from "../domain/functionComparison.js";
@@ -22,7 +27,6 @@ import { changedBehaviorResultSchema } from "../domain/changedBehavior.js";
 import { callPathResultSchema } from "../domain/callPath.js";
 import { staticRuntimeCorrelationResultSchema } from "../domain/staticRuntimeCorrelation.js";
 import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerification.js";
-import { replayMachineRunOutputSchema } from "../domain/replayMachineRun.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
 import { nativeDispatchMetadataResultSchema } from "../domain/objcSwiftMetadata.js";
 import { nativeInvestigationTraceSchema } from "../domain/nativeInvestigationGraph.js";
@@ -56,6 +60,9 @@ const addressedString = z.object({
 });
 /** Exact structured-content schemas shared by direct analysis providers. */
 export const officialOutputSchemas = {
+    inspect_native_data_type: resultOf(nativeDataTypeSchema),
+    inspect_native_instruction: resultOf(nativeInstructionSchema),
+    resolve_native_call_targets: resultOf(nativeCallTargetsSchema),
     address_name: resultOf(nullableText),
     comment: resultOf(nullableText),
     current_address: resultOf(z.string()),
@@ -91,6 +98,10 @@ export const officialOutputSchemas = {
     procedure_references: resultOf(z.object({
         procedure: procedureIdentity,
         direction: z.enum(["incoming", "outgoing"]),
+        reference_kinds_available: z.boolean().optional(),
+        unresolved_calls: z
+            .array(z.object({ address: z.string(), reason: z.string() }))
+            .default([]),
         references: z.array(z.object({
             source_address: z.string(),
             target_address: z.string(),
@@ -157,6 +168,7 @@ const callPathTraceOutput = resultOf(z.object({
 /** Exact structured-content schemas for composed analysis workflows. */
 export const enhancedOutputSchemas = {
     inspect_native_dispatch_metadata: resultOf(nativeDispatchMetadataResultSchema),
+    trace_native_values: resultOf(nativeValueTraceSchema),
     trace_native_ui_action: resultOf(nativeInvestigationTraceSchema),
     get_objc_classes: symbolDiscoveryOutput("classes"),
     get_objc_protocols: symbolDiscoveryOutput("protocols"),
@@ -213,11 +225,12 @@ export const enhancedOutputSchemas = {
     analyze_function: functionDossierOutput,
     inspect_native_api: resultOf(nativeApiInspectionResultSchema),
     trace_feature: literalTraceOutput,
-    find_code_for_string: literalTraceOutput,
     trace_call_path: callPathTraceOutput,
 };
 /** Exact Evidence schemas for provider-neutral native inspection. */
 export const nativeOutputSchemas = {
+    observe_native_ui: resultOf(nativeUiResultSchema),
+    capture_native_ui_scenario: resultOf(nativeUiResultSchema),
     inspect_macho: resultOf(inspectMachoSchema),
     inspect_signature: resultOf(inspectSignatureSchema),
     inspect_plist: resultOf(inspectPlistSchema),
@@ -229,6 +242,8 @@ export const artifactOutputSchemas = {
     inspect_artifact: resultOf(artifactInspectionResultSchema),
     extract_artifact: resultOf(artifactExtractionResultSchema),
     decode_interface_builder: resultOf(interfaceBuilderAnalysisSchema),
+    inspect_keyed_archive: resultOf(keyedArchiveResultSchema),
+    inspect_asset_catalog: resultOf(appleAssetCatalogResultSchema),
 };
 /** Exact Evidence schema for execution-free managed static analysis. */
 export const managedOutputSchemas = {
@@ -241,7 +256,6 @@ export const managedWorkflowOutputSchemas = {
     compare_managed_members: resultOf(managedMemberComparisonResultSchema),
     verify_managed_native_boundaries: resultOf(managedNativeVerificationResultSchema),
     import_managed_reconstruction: resultOf(managedReconstructionImportResultSchema),
-    plan_managed_runtime_correlation: resultOf(managedRuntimeCorrelationResultSchema),
     project_managed_application_graph: resultOf(managedApplicationGraphResultSchema),
 };
 /** Exact structured-content schemas for target lifecycle operations. */
@@ -323,5 +337,4 @@ export const sessionOutputSchemas = {
         truthVerified: z.boolean(),
         unknown: residualUnknownSchema,
     })),
-    run_replay_machine: lifecycleResultOf(replayMachineRunOutputSchema),
 };

package/dist/contracts/toolOutputSchemaPrimitives.js

@@ -1,17 +1,16 @@
 import { z } from "zod";
-import { procedureClassificationSchema, procedureIdentitySchema, localVariableSchema, functionDossierSchema, } from "../domain/hopperValues.js";
+import { procedureClassificationSchema, procedureIdentitySchema, localVariableSchema, functionDossierSchema, functionBodySchema, } from "../domain/hopperValues.js";
 import { analysisProfileSchema } from "../domain/analysisProfile.js";
 import { evidenceEnvelopeSchema } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { PROVIDER_REJECTION_CODES, } from "./providerSelection.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
 /** Inline result with its complete Evidence record. */
-export const inlineEvidenceRecordSchema = evidenceEnvelopeSchema.omit({
-    normalized_result: true,
-});
+export const inlineEvidenceRecordSchema = evidenceEnvelopeSchema;
 export const evidenceResultOf = (schema) => z.strictObject({
     result: schema,
-    evidence_id: z.string().regex(/^ev_[a-f0-9]{64}$/u),
+    evidence_id: prefixedDigestSchema("ev"),
     evidence: inlineEvidenceRecordSchema,
 });
 const resultOf = evidenceResultOf;
@@ -29,6 +28,7 @@ export const targetFormatSchema = z.enum([
     "mach-o",
     "elf",
     "pe",
+    "dos-mz",
     "zip",
     "ipa",
     "apk",
@@ -236,7 +236,6 @@ export const toolUnavailabilityReason = z.enum([
     "provider_unavailable",
     "target_unsupported",
     "unsupported_host",
-    "policy_disabled",
 ]);
 export const toolAvailability = z.discriminatedUnion("available", [
     z.object({
@@ -398,6 +397,10 @@ export const procedureInfoOutput = resultOf(z.object({
     signature: nullableText,
     locals: z.array(localVariable),
     classification: procedureClassificationSchema.nullable().default(null),
+    body: functionBodySchema.default({
+        available: false,
+        reason: "The provider did not report complete function body ranges.",
+    }),
 }));
 export const symbolDiscoveryOutput = (property) => resultOf(z.object({
     count: z.number().int().min(0),

package/dist/contracts/toolSchemaMetadata.js

@@ -1,12 +1,11 @@
 import { z } from "zod";
 const PROPERTY_DESCRIPTIONS = {
     addresses: "Ordered provider-normalized procedure addresses to analyze.",
-    approved: "Explicit operator approval to perform this operation.",
     after: "The later or right-hand observation to compare.",
     before: "The earlier or left-hand observation to compare.",
     boundary_id: "Exact reconstruction boundary identifier to evaluate.",
     case_sensitive: "Whether text matching distinguishes uppercase and lowercase.",
-    cdp_endpoint: "Approved literal loopback Chrome DevTools Protocol endpoint.",
+    cdp_endpoint: "Literal loopback Chrome DevTools Protocol endpoint.",
     comment: "Exact analyst comment text to write.",
     comparisons: "Validated comparison Evidence records to aggregate.",
     coverage: "Exact reconstruction-coverage commitment to verify.",
@@ -15,12 +14,12 @@ const PROPERTY_DESCRIPTIONS = {
     error: "Structured, caller-actionable error when the operation fails.",
     evidence: "Evidence record produced by this operation.",
     evidence_id: "Stable identifier of the recorded Evidence observation.",
-    executable: "Approved absolute path of the executable to run.",
+    executable: "Command name or executable path to run.",
     format: "Declared input artifact format.",
     name: "Exact name used by this operation.",
     pattern: "Literal text or regular expression used to filter matching results.",
     phase: "Current plan or execution phase of the operation.",
-    plan: "Content-bound execution plan and its approval commitment.",
+    plan: "Content-bound execution plan and its digest commitment.",
     query: "Non-empty feature or text query to investigate.",
     question: "Concrete unresolved question to retain for later investigation.",
     result: "Primary structured result returned by this operation.",
@@ -35,7 +34,7 @@ const PROPERTY_DESCRIPTIONS = {
     status: "Current lifecycle or verification status.",
     summary: "Concise evidence-backed summary of the result.",
     symbols: "Ordered Swift symbols to demangle.",
-    target_id: "Exact authorized CDP target identifier.",
+    target_id: "Exact CDP target identifier selected from the endpoint's target listing.",
     unknown_id: "Exact residual-unknown identifier.",
 };
 /** Attach caller guidance to a canonical schema for the SDK wire projection. */
@@ -88,8 +87,6 @@ const fallbackPropertyDescription = (property) => {
     if (explicit !== undefined)
         return explicit;
     const words = property.replaceAll("_", " ");
-    if (property.endsWith("_approved"))
-        return `Explicit operator approval for ${words.slice(0, -9)}.`;
     if (property.startsWith("max_"))
         return `Maximum permitted ${words.slice(4)} for this operation.`;
     if (property.startsWith("include_"))
@@ -109,7 +106,7 @@ const fallbackPropertyDescription = (property) => {
     if (property.endsWith("_bytes"))
         return `Byte count for ${words.slice(0, -6)}.`;
     if (property.endsWith("_root") || property.endsWith("_roots"))
-        return `Approved canonical filesystem ${words}.`;
+        return `Local filesystem ${words} selected for this operation.`;
     if (property.startsWith("is_") || property.startsWith("has_"))
         return `Whether ${words}.`;
     return `Value for ${words}.`;