rea-agents 4.1.0 → 6.0.0

package/dist/contracts/mobileApplicationGraphExamples.js

@@ -0,0 +1,105 @@
+import { canonicalDigest } from "../domain/comparisonSemantics.js";
+import { createEvidence } from "../domain/evidence.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+const inventory = (format, digit) => {
+    const sha = digit.repeat(64);
+    const artifactId = `art_${canonicalDigest({ sha256: sha }, "Artifact inventory")}`;
+    const occurrenceId = `occ_${canonicalDigest({ root: artifactId }, "Artifact inventory")}`;
+    const nodes = [
+        {
+            artifact_id: artifactId,
+            kind: "resource",
+            format,
+            sha256: sha,
+            size: 1,
+            media_type: null,
+            architecture: null,
+            executable: false,
+            content_state: "materialized",
+            limitations: [],
+        },
+    ];
+    const occurrences = [
+        {
+            occurrence_id: occurrenceId,
+            artifact_id: artifactId,
+            parent_occurrence_id: null,
+            logical_path: ".",
+            entry_kind: "file",
+            declared_size: 1,
+            compressed_size: null,
+            executable: false,
+            encrypted: false,
+            hash_status: "verified",
+            source_location: null,
+            limitations: [],
+        },
+    ];
+    const graphSha256 = canonicalDigest({
+        nodes,
+        occurrences,
+        edges: [],
+        integrity_contradictions: [],
+    }, "Artifact inventory");
+    return jsonValueSchema.parse({
+        manifest: {
+            manifest_id: `agm_${canonicalDigest({
+                root_artifact_id: artifactId,
+                graph_sha256: graphSha256,
+            }, "Artifact inventory")}`,
+            root_artifact_id: artifactId,
+            root_sha256: sha,
+            root_format: format,
+            graph_sha256: graphSha256,
+            node_count: nodes.length,
+            occurrence_count: occurrences.length,
+            edge_count: 0,
+        },
+        nodes,
+        occurrences,
+        edges: [],
+        provenance: [],
+        limitations: [],
+    });
+};
+const provider = {
+    id: "rea-artifact-graph",
+    name: "REA safe artifact graph provider",
+    version: "1",
+};
+/** Catalog example for Android application inventory projection. */
+export const ANDROID_APPLICATION_GRAPH_EXAMPLE = {
+    inventory_evidence: [
+        createEvidence({ path: "Fixture.apk", sha256: "a".repeat(64), format: "apk" }, provider, {
+            operation: "inventory_artifact",
+            parameters: {},
+            result: inventory("apk", "a"),
+            confidence: "observed",
+            authority: "shipped-artifact",
+        }),
+    ],
+};
+/** Catalog example for Apple application inventory projection. */
+export const APPLE_APPLICATION_GRAPH_EXAMPLE = {
+    inventory_evidence: [
+        createEvidence({ path: "Fixture.ipa", sha256: "b".repeat(64), format: "ipa" }, provider, {
+            operation: "inventory_artifact",
+            parameters: {},
+            result: inventory("ipa", "b"),
+            confidence: "observed",
+            authority: "shipped-artifact",
+        }),
+    ],
+};
+/** Catalog example for a macOS application bundle inventoried as a directory. */
+export const MACOS_APPLICATION_GRAPH_EXAMPLE = {
+    inventory_evidence: [
+        createEvidence({ path: "Fixture.app", sha256: "c".repeat(64), format: "directory" }, provider, {
+            operation: "inventory_artifact",
+            parameters: {},
+            result: inventory("directory", "c"),
+            confidence: "observed",
+            authority: "shipped-artifact",
+        }),
+    ],
+};

package/dist/contracts/native/binaryDiagnosticsToolContracts.js

@@ -0,0 +1,42 @@
+import { inspectRecordedCrashInputSchema, recordedCrashSchema, } from "../../domain/native/recordedCrash.js";
+import { inspectBinaryLayoutInputSchema, binaryLayoutSchema, } from "../../domain/native/binaryLayout.js";
+import { toolContractMetadata } from "../toolEffects.js";
+import { evidenceResultOf } from "../toolOutputSchemas.js";
+/** Offline binary diagnostics are independent of macOS process/UI providers. */
+export const BINARY_DIAGNOSTICS_TOOL_CONTRACTS = [
+    {
+        name: "inspect_binary_layout",
+        ...toolContractMetadata("inspect_binary_layout"),
+        kind: "native-provider",
+        description: "Inspect an explicit local binary without launching it as a host process. Returns file-backed section/segment ranges, linked addresses, original symbol/REL/RELA table identities, complete encoded RELR tables and upstream-derived offsets with unknown per-word locations/addends, raw name bytes, dependency/interpreter names and static mitigation inferences inline with artifact SHA-256 Evidence. Initial profile: ELF64 x86-64 little-endian EXEC/DYN/REL on Linux x64 via caller-supplied Python with unchanged pwntools 4.15.0, pyelftools 0.33 and Unicorn 2.1.2. Runtime addresses/library paths, overall relocation inventory completeness and complete derived GOT/PLT coverage remain unknown. Zero executable entry values mean absence; relocatable entries are not applicable. Upstream can emulate PLT instructions with Unicorn for derived static maps. Uses bounded complete output and owned temporary files/processes; malformed, unsupported or oversized objects return no partial success.",
+        inputSchema: inspectBinaryLayoutInputSchema,
+        outputSchema: evidenceResultOf(binaryLayoutSchema),
+        examples: [
+            {
+                title: "Inspect ELF linked and file layout",
+                input: { path: "/artifacts/application.elf" },
+            },
+        ],
+    },
+    {
+        name: "inspect_recorded_crash",
+        ...toolContractMetadata("inspect_recorded_crash"),
+        kind: "native-provider",
+        description: "Inspect a supplied Linux ELF64 amd64 little-endian core without launching its target or attaching to any live PID. Returns all recorded segments, raw note owners/descriptors and source ranges, every Linux CORE PRSTATUS thread/register and SIGINFO fields inline with SHA-256 Evidence. Historical PID is recorded metadata; current process/file identity, note coverage and signal-thread associations stay unknown. Optionally add derived core-only GDB/pwndbg mapping candidates through explicit BYO configuration; zero map flags mean unknown permissions. Uses the same stable snapshot for both stages, bounded complete output and owned cleanup. Initial Linux x64 profile: unchanged pwntools 4.15.0/pyelftools 0.33/Unicorn 2.1.2; optional unchanged pwndbg 2026.09.15. No implicit executable/library pairing, GDB command language, host configuration changes or dependency installation.",
+        inputSchema: inspectRecordedCrashInputSchema,
+        outputSchema: evidenceResultOf(recordedCrashSchema),
+        examples: [
+            {
+                title: "Inspect recorded registers and signal evidence",
+                input: { path: "/artifacts/crash.core" },
+            },
+            {
+                title: "Add core-only debugger mapping candidates",
+                input: {
+                    path: "/artifacts/crash.core",
+                    include_debugger_context: true,
+                },
+            },
+        ],
+    },
+];

package/dist/contracts/{nativeToolContracts.js → native/nativeToolContracts.js}

@@ -1,9 +1,10 @@
 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";
-import { requireOutputSchema } from "./toolOutputSchemaPrimitives.js";
+import { nativeCallObservationInputSchema } from "../../domain/native/nativeCallObservation.js";
+import { nativeUiObservationInputSchema, nativeUiScenarioInputSchema, } from "../../domain/native/nativeUiObservation.js";
+import { nativeOutputSchemas } from "../toolOutputSchemas.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { toolContractMetadata } from "../toolEffects.js";
+import { requireOutputSchema } from "../toolOutputSchemaPrimitives.js";
 const examples = {
     inspect_macho: {},
     inspect_signature: {},
@@ -16,15 +17,29 @@ const examples = {
         steps: [{ kind: "wait", milliseconds: 100 }],
     },
     demangle_swift: { symbols: ["$s4Test3fooyyF"] },
+    observe_native_calls: {
+        breakpoints: [
+            {
+                kind: "objc-method",
+                class_name: "NSURLSession",
+                selector: "dataTaskWithRequest:completionHandler:",
+            },
+            { kind: "function", name: "open", module: "libsystem_kernel.dylib" },
+        ],
+        arguments: ["--help"],
+        duration_ms: 5000,
+        backtrace_frames: 4,
+    },
 };
 const native = (name, description, inputSchema) => {
     const outputSchema = requireOutputSchema(nativeOutputSchemas, name);
+    const strictInputSchema = inputSchema.strict();
     return {
         name,
         ...toolContractMetadata(name),
         description,
         kind: "native-provider",
-        inputSchema,
+        inputSchema: strictInputSchema,
         outputSchema,
         examples: [
             {
@@ -36,17 +51,25 @@ const native = (name, description, inputSchema) => {
         ],
     };
 };
+/** Ordered single-line symbols; `swift-demangle` ends each result with LF. */
+export const swiftSymbolsSchema = z
+    .array(z
+    .string()
+    .min(1)
+    .regex(/^[^\n]*$/u, "Each Swift symbol must be one line."))
+    .min(1);
 /** 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("observe_native_calls", "Launch the active Mach-O as an owned process under LLDB and record each entry into caller-selected functions or Objective-C methods: thread, module, symbol, load and file address, raw argument registers, selector, receiver class and optional caller frames. Every hit auto-continues. No expression is evaluated and no other process is attached. The process is killed when max_events or duration_ms is reached; exit status, captured stdout/stderr, unresolved breakpoints and limitations are returned inline. The process runs with the current user's permissions and may change files, show UI or use the network. A hardened-runtime target needs the get-task-allow entitlement.", nativeCallObservationInputSchema),
     native("inspect_macho", "Inspect Mach-O slices, load commands, imports, exports, dependencies, build metadata, segments, sections, permissions, and exact command provenance without launching Hopper.", z.object({})),
     native("inspect_signature", "Inspect the active artifact's code-signing identity, hashes, authorities, requirements, entitlements, hardened-runtime state, and exact command provenance.", z.object({})),
     native("inspect_plist", "Parse Info.plist from the active artifact by default, or pass any local plist path. Returns normalized JSON rather than plutil text.", z.object({
         path: z.string().min(1).optional(),
     })),
     native("list_architectures", "List thin or universal Mach-O slices with offsets, sizes, alignment, explicit coverage, and native-tool provenance.", z.object({})),
-    native("demangle_swift", "Demangle an ordered list of Swift symbols without requiring Hopper. Each input returns demangled, unchanged, or invalid status.", z.object({
-        symbols: z.array(z.string().min(1)).min(1),
+    native("demangle_swift", "Demangle an ordered list of single-line Swift symbols without requiring Hopper. Each input returns demangled, unchanged, or invalid status.", z.object({
+        symbols: swiftSymbolsSchema,
     })),
 ];

package/dist/contracts/officialToolContracts.js

@@ -1,22 +1,25 @@
 import { z } from "zod";
-import { nativeFunctionAnnotationsInputSchema } from "../domain/nativeFunctionAnnotations.js";
+import { nativeFunctionAnnotationsInputSchema } from "../domain/native/nativeFunctionAnnotations.js";
 import { officialOutputSchemas, requireOutputSchema, } from "./toolOutputSchemas.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 { nativeDataTypeInputSchema } from "../domain/native/nativeDataType.js";
+import { nativeInstructionInputSchema } from "../domain/native/nativeInstruction.js";
 import { functionInstructionInputSchema } from "./functionInstructionContract.js";
 import { HOPPER_MEMORY_TOOL_DEFINITIONS } from "./hopperMemoryContracts.js";
 import { analysisSearchInput } from "./analysisSearchContract.js";
-const official = (name, description, inputSchema) => ({
-    name,
-    ...toolContractMetadata(name),
-    description,
-    kind: "official-proxy",
-    inputSchema,
-    outputSchema: requireOutputSchema(officialOutputSchemas, name),
-    examples: examplesFor(name, inputSchema),
-});
+const official = (name, description, inputSchema) => {
+    const strictInputSchema = inputSchema.strict();
+    return {
+        name,
+        ...toolContractMetadata(name),
+        description,
+        kind: "official-proxy",
+        inputSchema: strictInputSchema,
+        outputSchema: requireOutputSchema(officialOutputSchemas, name),
+        examples: examplesFor(name, strictInputSchema),
+    };
+};
 /** Bridge operations exposed without additional application composition. */
 export const OFFICIAL_TOOL_CONTRACTS = [
     official("annotate_native_function", "Atomically update one function name and/or entry comments, read them back, and return a refreshed complete function dossier. Ghidra changes its ephemeral session analysis database only; original executable bytes remain unchanged. Empty comment text clears that comment. Edits remain available to subsequent MCP calls until close; CLI returns the updated dossier before discarding its session. Invalid edits roll back the entire operation. Windows P0 and providers without this capability are unsupported.", nativeFunctionAnnotationsInputSchema),

package/dist/contracts/process/processCaptureExample.js

@@ -0,0 +1,2 @@
+/** Minimal valid process capture retained as a public contract example. */
+export { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../../domain/process/processCaptureExample.js";

package/dist/contracts/sessionLifecycleInputs.js

@@ -1,17 +1,34 @@
 import { executableFormatHintSchema } from "../domain/dosCom.js";
+import { isAbsoluteLocalPath } from "../domain/localPath.js";
 import { z } from "zod";
 import { analysisProviderSelectorSchema } from "./providerSelection.js";
+/** Caller-supplied analysis snapshot path; must name its destination absolutely. */
+const snapshotPathSchema = z
+    .string()
+    .min(1)
+    .refine(isAbsoluteLocalPath, {
+    message: "snapshot_path must be an absolute local filesystem path (for example /tmp/rea/analysis.json or C:\\rea\\analysis.json)",
+})
+    .describe("Absolute local filesystem path for the analysis snapshot; relative paths are rejected.");
+/** Caller-supplied analysis target path; must name the target absolutely. */
+const binaryTargetPathSchema = z
+    .string()
+    .min(1)
+    .refine(isAbsoluteLocalPath, {
+    message: "path must be an absolute local filesystem path (for example /tmp/fixture.bin or C:\\analysis\\fixture.bin)",
+})
+    .describe("Absolute local filesystem path for the analysis target; relative paths are rejected.");
 /** Input contract for opening a target with an optional staged snapshot. */
-export const openBinaryInputSchema = z.object({
-    path: z.string().min(1),
+export const openBinaryInputSchema = z.strictObject({
+    path: binaryTargetPathSchema,
     format: executableFormatHintSchema
         .optional()
         .describe("Explicit headerless DOS COM interpretation; omission preserves header-based detection"),
     provider_id: analysisProviderSelectorSchema.optional(),
-    snapshot_path: z.string().min(1).optional(),
+    snapshot_path: snapshotPathSchema.optional(),
 });
 /** Input contract for closing a target after an optional atomic snapshot. */
-export const closeBinaryInputSchema = z.object({
-    snapshot_path: z.string().min(1).optional(),
+export const closeBinaryInputSchema = z.strictObject({
+    snapshot_path: snapshotPathSchema.optional(),
     overwrite: z.boolean().default(false),
 });

package/dist/contracts/sessionStatusContract.js

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

package/dist/contracts/sessionToolContracts.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { isAbsoluteLocalPath } from "../domain/localPath.js";
 import { sessionOutputSchemas, requireOutputSchema, } from "./toolOutputSchemas.js";
 import { addressContextInputSchema, artifactComparisonInputSchema, binarySessionInputSchema, bundleComparisonInputSchema, callPathInputSchema, changedBehaviorInputSchema, closeBinaryInputSchema, functionComparisonInputSchema, importEvidenceBundleInputSchema, listUnknownsInputSchema, navigationContextInputSchema, openBinaryInputSchema, processComparisonInputSchema, processScenarioSchema, reconstructionVerificationInputSchema, recordUnknownInputSchema, getEvidenceBundleInputSchema, staticRuntimeCorrelationInputSchema, updateUnknownInputSchema, verifyUnknownResolutionInputSchema, } from "./sessionToolSchemas.js";
 import { examplesFor } from "./toolContractHelpers.js";
@@ -14,7 +15,13 @@ const session = (name, description, inputSchema) => ({
 });
 /** Session-owned Evidence bundle export options. */
 export const exportEvidenceBundleInputSchema = z.strictObject({
-    path: z.string().min(1),
+    path: z
+        .string()
+        .min(1)
+        .refine(isAbsoluteLocalPath, {
+        message: "path must be an absolute local filesystem path (for example /tmp/rea/evidence.json or C:\\rea\\evidence.json)",
+    })
+        .describe("Absolute local filesystem path for the exported evidence bundle; relative paths are rejected."),
     overwrite: z.boolean().default(false),
 });
 /** Target lifecycle tools available only on the long-lived MCP adapter. */
@@ -24,7 +31,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 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("capture_process_scenario", "Run one caller-selected command under a PTY and return process capture Evidence with residual unknowns. A command name resolves through the inherited PATH; the working directory defaults to the caller's current directory; host environment variables are inherited with scenario overrides. Environment keys cannot contain '=' or NUL, and REA_PROCESS_RUN_ID is reserved for process ownership. Filesystem snapshots are opt-in through filesystem_observation_paths. The target runs with the current user's permissions; this is not a security sandbox.", processScenarioSchema),
     session("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),

package/dist/contracts/sessionToolSchemas.js

@@ -1,12 +1,13 @@
 import { z } from "zod";
+import { isAbsoluteLocalPath } from "../domain/localPath.js";
 import { artifactComparisonInputSchema } from "../domain/artifactComparison.js";
 import { bundleComparisonInputSchema } from "../domain/bundleComparison.js";
 import { callPathInputSchema } from "../domain/callPath.js";
 import { changedBehaviorInputSchema } from "../domain/changedBehavior.js";
 import { functionComparisonInputSchema } from "../domain/functionComparison.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
-import { processScenarioSchema } from "../domain/processCapture.js";
-import { processTraceSpecificationSchema } from "../domain/processTraceComparison.js";
+import { processScenarioSchema } from "../domain/process/processCapture.js";
+import { processTraceSpecificationSchema } from "../domain/process/processTraceComparison.js";
 import { recordUnknownInputSchema } from "../domain/residualUnknown.js";
 import { reconstructionVerificationInputSchema } from "../domain/reconstructionVerification.js";
 import { staticRuntimeCorrelationInputSchema } from "../domain/staticRuntimeCorrelation.js";
@@ -28,7 +29,13 @@ export const addressContextInputSchema = z.strictObject({
 });
 /** Session-owned Evidence bundle import options. */
 export const importEvidenceBundleInputSchema = z.strictObject({
-    path: z.string().min(1),
+    path: z
+        .string()
+        .min(1)
+        .refine(isAbsoluteLocalPath, {
+        message: "path must be an absolute local filesystem path (for example /tmp/evidence.json or C:\\rea\\evidence.json)",
+    })
+        .describe("Absolute local filesystem path for the evidence bundle to import; relative paths are rejected."),
 });
 /** Evidence references for deterministic process comparison. */
 export const processComparisonInputSchema = z.strictObject({

package/dist/contracts/toolContractExamples.js

@@ -47,7 +47,7 @@ export const TOOL_EXAMPLE_OVERRIDES = {
     open_binary: { path: "/tmp/fixture" },
     export_evidence_bundle: { path: "/tmp/evidence.json" },
     inspect_address_context: { address: "0x1000" },
-    import_evidence_bundle: { path: "evidence.json" },
+    import_evidence_bundle: { path: "/tmp/evidence.json" },
     capture_process_scenario: {
         executable: "/usr/bin/true",
         working_directory: "/tmp",

package/dist/contracts/toolContracts.js

@@ -1,13 +1,19 @@
-import { NATIVE_TOOL_CONTRACTS } from "./nativeToolContracts.js";
+import { EVM_TOOL_CONTRACTS } from "./evm/evmToolContracts.js";
+import { BINARY_DIAGNOSTICS_TOOL_CONTRACTS } from "./native/binaryDiagnosticsToolContracts.js";
+import { NATIVE_TOOL_CONTRACTS } from "./native/nativeToolContracts.js";
 import { ARTIFACT_TOOL_CONTRACTS } from "./artifactToolContracts.js";
-import { MANAGED_TOOL_CONTRACTS } from "./managedToolContracts.js";
-import { FIRMWARE_TOOL_CONTRACTS } from "./firmwareToolContracts.js";
-import { ANDROID_TOOL_CONTRACTS } from "./androidToolContracts.js";
-import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "./managedWorkflowToolContracts.js";
+import { MANAGED_TOOL_CONTRACTS } from "./managed/managedToolContracts.js";
+import { FIRMWARE_TOOL_CONTRACTS } from "./firmware/firmwareToolContracts.js";
+import { ANDROID_TOOL_CONTRACTS } from "./android/androidToolContracts.js";
+import { MANAGED_WORKFLOW_TOOL_CONTRACTS } from "./managed/managedWorkflowToolContracts.js";
 import { BROWSER_PROVIDER_TOOL_CONTRACTS } from "./browserProviderToolContracts.js";
-import { ELECTRON_TOOL_CONTRACTS } from "./electronToolContracts.js";
-import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "./javascriptRuntimeObservationToolContracts.js";
+import { ELECTRON_TOOL_CONTRACTS } from "./javascript/electronToolContracts.js";
+import { JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS } from "./javascript/javascriptRuntimeObservationToolContracts.js";
 import { APPLICATION_TOOL_CONTRACTS } from "./applicationToolContracts.js";
+import { WEB_SCRIPT_TOOL_CONTRACTS } from "./webScriptToolContracts.js";
+import { WEB_RUNTIME_TOOL_CONTRACTS } from "./webRuntimeToolContracts.js";
+import { WEB_NETWORK_CAPTURE_TOOL_CONTRACTS } from "./webNetworkCaptureToolContracts.js";
+import { JAVASCRIPT_RECOVERY_TOOL_CONTRACTS } from "./javascript/javascriptRecoveryToolContracts.js";
 import { OFFICIAL_TOOL_CONTRACTS } from "./officialToolContracts.js";
 import { ENHANCED_TOOL_CONTRACTS } from "./enhancedToolContracts.js";
 import { SESSION_TOOL_CONTRACTS } from "./sessionToolContracts.js";
@@ -16,7 +22,9 @@ export const TOOL_CONTRACTS = [
     ...OFFICIAL_TOOL_CONTRACTS,
     ...ENHANCED_TOOL_CONTRACTS,
     ...NATIVE_TOOL_CONTRACTS,
+    ...BINARY_DIAGNOSTICS_TOOL_CONTRACTS,
     ...ARTIFACT_TOOL_CONTRACTS,
+    ...EVM_TOOL_CONTRACTS,
     ...MANAGED_TOOL_CONTRACTS,
     ...ANDROID_TOOL_CONTRACTS,
     ...FIRMWARE_TOOL_CONTRACTS,
@@ -25,6 +33,10 @@ export const TOOL_CONTRACTS = [
     ...ELECTRON_TOOL_CONTRACTS,
     ...JAVASCRIPT_RUNTIME_OBSERVATION_TOOL_CONTRACTS,
     ...APPLICATION_TOOL_CONTRACTS,
+    ...WEB_SCRIPT_TOOL_CONTRACTS,
+    ...WEB_RUNTIME_TOOL_CONTRACTS,
+    ...WEB_NETWORK_CAPTURE_TOOL_CONTRACTS,
+    ...JAVASCRIPT_RECOVERY_TOOL_CONTRACTS,
     ...SESSION_TOOL_CONTRACTS,
 ];
 /** Resolve a public contract by name while retaining its exact schema types. */

package/dist/contracts/toolEffects.js

@@ -18,6 +18,45 @@ const browserEvidence = effects({
 const sessionEvidence = effects({ mutatesSession: true });
 /** Explicit effect audit for every public tool. */
 export const TOOL_EFFECTS = {
+    inspect_evm_interface: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+    }),
+    inspect_web_network_capture: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+    }),
+    observe_web_execution: effects({
+        mutatesTarget: true,
+        mutatesSession: true,
+        accessesNetwork: true,
+        mayDiscardData: true,
+        idempotent: false,
+    }),
+    inspect_web_event_listeners: browserEvidence,
+    trace_web_source_location: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+    }),
+    trace_web_module_imports: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+        accessesNetwork: true,
+    }),
+    inspect_recorded_crash: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+    }),
+    inspect_binary_layout: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+    }),
     inspect_firmware_regions: effects({
         mutatesSession: true,
         launchesProcess: true,
@@ -133,6 +172,15 @@ export const TOOL_EFFECTS = {
         mayDiscardData: true,
         idempotent: false,
     }),
+    // The owned process can change files, show UI and use the network.
+    observe_native_calls: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+        accessesNetwork: true,
+        changesUiState: true,
+        idempotent: false,
+    }),
     inspect_macho: nativeEvidence,
     inspect_signature: nativeEvidence,
     inspect_plist: nativeEvidence,
@@ -152,6 +200,7 @@ export const TOOL_EFFECTS = {
     decode_interface_builder: evidence,
     inspect_asset_catalog: nativeEvidence,
     inspect_keyed_archive: evidence,
+    trace_dylib_resolution: evidence,
     inspect_managed_artifact: evidence,
     inspect_managed_members: evidence,
     inspect_managed_native_boundaries: evidence,
@@ -192,7 +241,18 @@ export const TOOL_EFFECTS = {
     list_javascript_runtime_targets: browserEvidence,
     observe_javascript_runtime: browserEvidence,
     analyze_javascript_application: evidence,
+    export_web_scripts: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        idempotent: false,
+    }),
     reconcile_javascript_runtime: evidence,
+    recover_javascript_sources: effects({
+        mutatesSession: true,
+        writesFilesystem: true,
+        launchesProcess: true,
+        idempotent: false,
+    }),
     trace_application_feature: evidence,
     trace_javascript_semantics: evidence,
     compare_application_versions: evidence,
@@ -200,6 +260,8 @@ export const TOOL_EFFECTS = {
     compare_javascript_export_shapes: evidence,
     build_reconstruction_obligation_ledger: evidence,
     evaluate_reconstruction_coverage: effects(),
+    project_android_application_graph: evidence,
+    project_apple_application_graph: evidence,
     open_binary: effects({ mutatesSession: true, launchesProcess: true }),
     close_binary: effects({
         mutatesSession: true,

package/dist/contracts/toolOutputSchemaGroups.js

@@ -1,27 +1,29 @@
 import { z } from "zod";
-import { nativeFunctionAnnotationsSchema } from "../domain/nativeFunctionAnnotations.js";
-import { nativeLoadImageSchema } from "../domain/nativeLoadImage.js";
-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 { nativeFunctionAnnotationsSchema } from "../domain/native/nativeFunctionAnnotations.js";
+import { nativeLoadImageSchema } from "../domain/native/nativeLoadImage.js";
+import { nativeUiResultSchema } from "../domain/native/nativeUiObservation.js";
+import { nativeValueTraceSchema } from "../domain/native/nativeValueTrace.js";
+import { nativeDataTypeSchema } from "../domain/native/nativeDataType.js";
+import { nativeCallObservationResultSchema } from "../domain/native/nativeCallObservation.js";
+import { nativeInstructionSchema, nativeCallTargetsSchema, } from "../domain/native/nativeInstruction.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { residualUnknownSchema } from "../domain/residualUnknown.js";
 import { evidenceBundleSchema } from "../domain/evidenceBundle.js";
-import { processCaptureComparisonSchema, processCaptureSchema, } from "../domain/processCapture.js";
+import { processCaptureComparisonSchema, processCaptureSchema, } from "../domain/process/processCapture.js";
 import { functionInstructionWindowSchema, referenceKindSchema, } from "../domain/hopperValues.js";
-import { nativeApiInspectionResultSchema } from "../domain/nativeApiBoundary.js";
-import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/nativeInspection.js";
+import { nativeApiInspectionResultSchema } from "../domain/native/nativeApiBoundary.js";
+import { demangleSwiftSchema, inspectMachoSchema, inspectPlistSchema, inspectSignatureSchema, listArchitecturesSchema, } from "../domain/native/nativeInspection.js";
 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 { managedApplicationGraphResultSchema } from "../domain/managedApplicationGraph.js";
+import { interfaceBuilderAnalysisSchema } from "../domain/apple/interfaceBuilderGraph.js";
+import { dylibResolutionResultSchema } from "../domain/apple/dylibResolution.js";
+import { keyedArchiveResultSchema } from "../domain/apple/keyedArchive.js";
+import { appleAssetCatalogResultSchema } from "../domain/apple/appleAssetCatalog.js";
+import { managedArtifactInspectionSchema, managedMemberInspectionSchema, managedNativeBoundaryInspectionSchema, } from "../domain/managed/managedArtifact.js";
+import { managedMemberComparisonResultSchema } from "../domain/managed/managedMemberComparison.js";
+import { managedNativeVerificationResultSchema } from "../domain/managed/managedNativeVerification.js";
+import { managedReconstructionImportResultSchema } from "../domain/managed/managedReconstruction.js";
+import { managedApplicationGraphResultSchema } from "../domain/managed/managedApplicationGraph.js";
 import { artifactComparisonResultSchema } from "../domain/artifactComparison.js";
 import { functionComparisonResultSchema } from "../domain/functionComparison.js";
 import { bundleComparisonResultSchema } from "../domain/bundleComparison.js";
@@ -30,8 +32,8 @@ import { callPathResultSchema } from "../domain/callPath.js";
 import { staticRuntimeCorrelationResultSchema } from "../domain/staticRuntimeCorrelation.js";
 import { reconstructionVerificationResultSchema } from "../domain/reconstructionVerification.js";
 import { analysisErrorProjectionSchema } from "./errorSchemas.js";
-import { nativeDispatchMetadataResultSchema } from "../domain/objcSwiftMetadata.js";
-import { nativeInvestigationTraceSchema } from "../domain/nativeInvestigationGraph.js";
+import { nativeDispatchMetadataResultSchema } from "../domain/native/objcSwiftMetadata.js";
+import { nativeInvestigationTraceSchema } from "../domain/native/nativeInvestigationGraph.js";
 import { addressList, addressedValue, addressedEntry, containingProcedureResolution, functionDossierOutput, graphNode, lifecycleResultOf, nullableText, procedureIdentity, procedureInfoOutput, evidenceResultOf as resultOf, segmentOutput, sessionProvider, symbolDiscoveryOutput, targetFormatSchema, targetKindSchema, } from "./toolOutputSchemaPrimitives.js";
 const contextFacetSchema = z.discriminatedUnion("state", [
     z.object({ state: z.literal("available"), value: jsonValueSchema }),
@@ -235,6 +237,7 @@ export const enhancedOutputSchemas = {
 export const nativeOutputSchemas = {
     observe_native_ui: resultOf(nativeUiResultSchema),
     capture_native_ui_scenario: resultOf(nativeUiResultSchema),
+    observe_native_calls: resultOf(nativeCallObservationResultSchema),
     inspect_macho: resultOf(inspectMachoSchema),
     inspect_signature: resultOf(inspectSignatureSchema),
     inspect_plist: resultOf(inspectPlistSchema),
@@ -248,6 +251,7 @@ export const artifactOutputSchemas = {
     decode_interface_builder: resultOf(interfaceBuilderAnalysisSchema),
     inspect_keyed_archive: resultOf(keyedArchiveResultSchema),
     inspect_asset_catalog: resultOf(appleAssetCatalogResultSchema),
+    trace_dylib_resolution: resultOf(dylibResolutionResultSchema),
 };
 /** Exact Evidence schema for execution-free managed static analysis. */
 export const managedOutputSchemas = {

package/dist/contracts/toolOutputSchemaPrimitives.js

@@ -305,7 +305,7 @@ export const sessionProvider = z
         negotiated_protocol_version: z.string().nullable(),
         client: z.object({ name: z.string(), version: z.string() }).nullable(),
         skill: z.object({ name: z.string(), expected_version: z.string() }),
-        catalog: z.record(z.string(), z.json()),
+        catalog: z.record(z.string(), jsonValueSchema),
         protocol_features: z.object({
             progress: z.boolean(),
             cancellation: z.boolean(),