rea-agents 5.0.0 → 6.1.0

package/dist/cli/electronCommands.js

@@ -9,35 +9,40 @@ import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
-import { parseCliJsonInput } from "../cliJsonInput.js";
+import { parseCliJsonInput, resolveCliJsonPaths } from "../cliJsonInput.js";
 import { electronPageInspectionOptions, javascriptApplicationOptions, } from "../cliObservationOptions.js";
 import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
+import { withCommandCancellation } from "./commandCancellation.js";
 /** Register CLI equivalents of the Electron MCP tools. */
-export const registerElectronCommands = (cli, logger) => {
+export const registerElectronCommands = (cli, logger, resultOutput) => {
     registerElectronObservationCommands(cli, logger);
     registerElectronActiveCommand(cli, logger);
-    registerJavaScriptApplicationCommand(cli, logger);
+    registerJavaScriptApplicationCommand(cli, logger, resultOutput);
     registerJavaScriptRuntimeReconciliationCommand(cli, logger);
 };
 const registerElectronActiveCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.captureElectronScenario, {
-        description: "Run one bounded owned Electron scenario",
+        description: "Run one owned Electron scenario with cancellable actions",
         args: z.object({
             inputJson: z
                 .string()
                 .describe("Inline JSON or a JSON file matching capture_electron_scenario"),
         }),
-        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.captureElectronScenario, async () => {
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.captureElectronScenario, async () => {
             const input = await parseCliJsonInput(args.inputJson, "capture_electron_scenario");
             if (!input.ok)
                 return input.error;
-            const parsed = electronActiveObservationInputSchema.safeParse(input.value);
+            const parsed = electronActiveObservationInputSchema.safeParse(resolveCliJsonPaths(input.value, [
+                ["executable_path"],
+                ["application_path"],
+                ["application_root"],
+            ]));
             if (!parsed.success)
                 return inputError("capture_electron_scenario", parsed.error.issues, input.value);
             const { createElectronScenarioProvider } = await import("../composition/electronScenario.js");
-            const result = await captureElectronScenario(createElectronScenarioProvider(), parsed.data);
+            const result = await captureElectronScenario(createElectronScenarioProvider(), parsed.data, { signal });
             return result.ok ? result.value : cliError(result.error);
-        }),
+        })),
     });
 };
 const registerJavaScriptRuntimeReconciliationCommand = (cli, logger) => {
@@ -102,17 +107,20 @@ const registerElectronPageInspection = (cli, logger) => {
         }),
     });
 };
-const registerJavaScriptApplicationCommand = (cli, logger) => {
+const registerJavaScriptApplicationCommand = (cli, logger, resultOutput) => {
     cli.command(CLI_COMMANDS.analyzeJavaScriptApplication, {
         description: "Statically reconstruct a local JavaScript/Electron application",
         args: z.object({
             path: z.string().describe("ASAR or extracted application path"),
         }),
         options: javascriptApplicationOptions,
-        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({
-            input_path: args.path,
-            format: options.artifactFormat,
-        })),
+        run: ({ args, options, format }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({ input_path: args.path, format: options.artifactFormat }, resultOutput === undefined
+            ? undefined
+            : {
+                output: resultOutput,
+                command: CLI_COMMANDS.analyzeJavaScriptApplication,
+                format,
+            }, signal))),
     });
 };
 const electronObservationContext = async () => {

package/dist/cli/evmCommands.js

@@ -0,0 +1,24 @@
+import { z } from "incur";
+import { resolve } from "node:path";
+import { createEvmInterfaceService } from "../composition/evm.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Resolve operator paths and preserve explicit encoding through the shared workflow. */
+export const registerEvmCommands = (cli, logger, environment) => {
+    const service = createEvmInterfaceService(environment);
+    cli.command(CLI_COMMANDS.inspectEvmInterface, {
+        description: "Infer interface candidates from explicit local EVM bytecode",
+        args: z.object({
+            path: z.string().describe("Local bytecode carrier"),
+            encoding: z
+                .enum(["raw", "hex"])
+                .describe("Selected carrier representation"),
+        }),
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectEvmInterface, async () => {
+            const result = await service.inspect({ path: resolve(args.path), encoding: args.encoding }, { signal });
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
+    });
+};

package/dist/cli/firmwareCommands.js

@@ -1,4 +1,5 @@
 import { z } from "incur";
+import { resolve } from "node:path";
 import { FirmwareAnalysisService } from "../application/firmware/FirmwareAnalysisService.js";
 import { createFirmwareAnalysisProvider } from "../composition/firmware.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
@@ -16,7 +17,9 @@ export const registerFirmwareCommands = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.inspectFirmwareRegions, {
         description: "Inspect firmware signature candidates without extracting them",
         args: z.object({ path }),
-        run: ({ args }) => execute(CLI_COMMANDS.inspectFirmwareRegions, "inspect_firmware_regions", args),
+        run: ({ args }) => execute(CLI_COMMANDS.inspectFirmwareRegions, "inspect_firmware_regions", 
+        // CLI paths are operator-relative; resolve before shared validation.
+        { path: resolve(args.path) }),
     });
     cli.command(CLI_COMMANDS.extractFirmware, {
         description: "Extract selected firmware bytes and return verified files and provenance",
@@ -56,8 +59,8 @@ export const registerFirmwareCommands = (cli, logger, environment) => {
                 .describe("Staging entry budget; default 10000"),
         }),
         run: ({ args, options }) => execute(CLI_COMMANDS.extractFirmware, "extract_firmware", {
-            path: args.path,
-            output_directory: args.outputDirectory,
+            path: resolve(args.path),
+            output_directory: resolve(args.outputDirectory),
             ...(options.offset === undefined && options.length === undefined
                 ? {}
                 : { range: { offset: options.offset, length: options.length } }),

package/dist/cli/javascriptApplicationAnalysis.js

@@ -1,9 +1,26 @@
 import { analyzeJavaScriptApplication } from "../application/javascript/JavaScriptApplicationService.js";
+import { createProgressReporter } from "../application/ProgressReporter.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 /** Execute the shared one-shot CLI boundary for static JavaScript analysis. */
-export const runCliJavaScriptApplicationAnalysis = async (input) => {
-    const result = await analyzeJavaScriptApplication(input);
-    return result.ok ? result.value : cliError(result.error);
+export const runCliJavaScriptApplicationAnalysis = async (input, output, signal) => {
+    const started = performance.now();
+    const progress = createProgressReporter(async (update) => {
+        process.stderr.write(`${JSON.stringify({ rea_progress: update })}\n`);
+    }, { minimumIntervalMs: 0 });
+    const result = await analyzeJavaScriptApplication(input, {
+        progress,
+        ...(signal === undefined ? {} : { signal }),
+    });
+    const value = result.ok ? result.value : cliError(result.error);
+    if (output !== undefined &&
+        (await output.output.write(value, {
+            command: output.command,
+            format: output.format,
+            duration: `${Math.round(performance.now() - started)}ms`,
+        })))
+        // Keep failures visible to command logging after the stream has handled stdout.
+        return result.ok ? undefined : value;
+    return value;
 };
 const cliError = (error) => ({
     error: "JavaScript application analysis failed",

package/dist/cli/jsonOutput.js

@@ -0,0 +1,38 @@
+import { bufferedJsonParts, jsonParts } from "../domain/jsonSerialization.js";
+/** Write ordinary JSON without constructing a document-sized string. */
+export const writeJsonOutput = async (value, destination, format = "json") => {
+    for (const part of bufferedJsonParts(documentParts(value, format)))
+        await writePart(destination, part);
+};
+const writePart = (destination, part) => new Promise((resolve, reject) => {
+    const onError = (cause) => reject(cause);
+    destination.once("error", onError);
+    try {
+        destination.write(part, (cause) => {
+            if (cause) {
+                // A Writable can emit its error after invoking the write callback.
+                setImmediate(() => destination.off("error", onError));
+                reject(cause);
+            }
+            else {
+                destination.off("error", onError);
+                resolve();
+            }
+        });
+    }
+    catch (cause) {
+        destination.off("error", onError);
+        reject(cause);
+    }
+});
+function* documentParts(value, format) {
+    if (format === "jsonl" && Array.isArray(value)) {
+        for (const item of value) {
+            yield* jsonParts(item);
+            yield "\n";
+        }
+        return;
+    }
+    yield* jsonParts(value, format === "json");
+    yield "\n";
+}

package/dist/cli/nativeCallCommands.js

@@ -0,0 +1,34 @@
+import { z } from "incur";
+import { runProviderAnalysis } from "../composition/directAnalysis.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { parseCliJsonInput } from "../cliJsonInput.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { nativeCallObservationInputSchema } from "../domain/native/nativeCallObservation.js";
+const OPERATION = "observe_native_calls";
+/** `observe-native-calls <path> <input-json>`: the MCP input object as JSON. */
+export const registerNativeCallCommands = (cli, logger) => {
+    cli.command(CLI_COMMANDS.observeNativeCalls, {
+        description: "Launch a Mach-O under LLDB and record entries into selected functions or Objective-C methods",
+        args: z.object({
+            path: z.string().describe("Mach-O or app path"),
+            inputJson: z
+                .string()
+                .describe("Inline JSON or a JSON file path: breakpoints, arguments, environment, duration_ms, max_events, argument_registers, backtrace_frames"),
+        }),
+        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.observeNativeCalls, async () => {
+            const input = await parseCliJsonInput(args.inputJson, OPERATION);
+            if (!input.ok)
+                return input.error;
+            const parsed = nativeCallObservationInputSchema.safeParse(input.value);
+            if (!parsed.success)
+                return {
+                    error: "Analysis failed",
+                    ...projectAnalysisError(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, input.value)),
+                };
+            return runProviderAnalysis(args.path, OPERATION, z.record(z.string(), jsonValueSchema).parse(parsed.data), logger);
+        }),
+    });
+};

package/dist/cli/processCommands.js

@@ -1,5 +1,5 @@
 import { Cli, z } from "incur";
-import { captureProcessScenarioFile, compareProcessEvidenceFiles, isProcessCliFailure, } from "../application/ProcessCli.js";
+import { captureProcessScenarioFile, compareProcessEvidenceFiles, isProcessCliFailure, } from "../application/process/ProcessCli.js";
 import { logCliCommand } from "../cliLogging.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 /** Register direct process capture and comparison commands. */

package/dist/cli/streamedJsonOutput.js

@@ -0,0 +1,56 @@
+import {} from "node:stream";
+import { Filter } from "incur";
+import { parseCliOutputArguments } from "../cliOutput.js";
+import { writeJsonOutput } from "./jsonOutput.js";
+/** Preserve Incur's JSON controls while streaming the complete result. */
+export const createStreamedCliJsonOutput = (arguments_, destination) => {
+    const options = parseCliOutputArguments(arguments_);
+    if (options.parseError ||
+        options.tokenCount ||
+        options.tokenWindow ||
+        (options.format !== "json" && options.format !== "jsonl"))
+        return undefined;
+    const format = options.format;
+    let handled = false;
+    let failed = false;
+    return {
+        get handled() {
+            return handled;
+        },
+        get failed() {
+            return failed;
+        },
+        async write(value, metadata) {
+            if (metadata.format !== format)
+                return false;
+            const filtered = options.filterOutput
+                ? Filter.apply(value, Filter.parse(options.filterOutput))
+                : value;
+            const meta = {
+                command: metadata.command,
+                duration: metadata.duration,
+            };
+            const document = options.fullOutput
+                ? filtered === undefined
+                    ? { ok: true, meta }
+                    : { ok: true, data: filtered, meta }
+                : filtered === undefined ||
+                    filtered === null ||
+                    typeof filtered === "function" ||
+                    typeof filtered === "symbol"
+                    ? {}
+                    : filtered;
+            // Once writing starts, a failed destination must not receive a second
+            // document from Incur's error formatter.
+            handled = true;
+            try {
+                await writeJsonOutput(document, destination, format);
+            }
+            catch (cause) {
+                failed = true;
+                throw cause;
+            }
+            return true;
+        },
+    };
+};

package/dist/cli/utilityCommands.js

@@ -13,9 +13,11 @@ import { logCliCommand } from "../cliLogging.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { swiftSymbolsSchema } from "../contracts/native/nativeToolContracts.js";
 import { isReferenceSourceImportCliFailure } from "./referenceSourceImportStatus.js";
+import { registerNativeCallCommands } from "./nativeCallCommands.js";
 export const registerUtilityCommands = (cli, logger, environment = process.env) => {
     registerCapabilityCommands(cli, logger);
     registerNativeCommands(cli, logger);
+    registerNativeCallCommands(cli, logger);
     for (const [command, operation] of [
         [CLI_COMMANDS.observeNativeUi, "observe_native_ui"],
         [CLI_COMMANDS.captureNativeUiScenario, "capture_native_ui_scenario"],

package/dist/cli/webNetworkCaptureCommands.js

@@ -0,0 +1,40 @@
+import { z } from "incur";
+import { createWebNetworkCaptureService } from "../composition/webNetworkCaptures.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Expose offline historical capture inspection with the same selection contract as MCP. */
+export const registerWebNetworkCaptureCommands = (cli, logger, environment) => {
+    const service = createWebNetworkCaptureService(environment);
+    cli.command(CLI_COMMANDS.inspectWebNetworkCapture, {
+        description: "Inspect retained HAR or native mitmproxy records without fetching recorded URLs",
+        args: z.object({
+            capturePath: z.string().describe("Absolute local capture path"),
+            format: z.enum(["har", "mitmproxy"]).describe("Producer capture format"),
+        }),
+        options: z.object({
+            record: z
+                .array(z.coerce.number().int().nonnegative())
+                .optional()
+                .describe("Zero-based producer ordinals; repeat to select several"),
+            sensitiveValue: z
+                .array(z.string().min(1))
+                .default([])
+                .describe("Literal string values explicitly marked sensitive; repeat as needed"),
+        }),
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.inspectWebNetworkCapture, async () => {
+            const result = await service.inspect({
+                capture_path: args.capturePath,
+                format: args.format,
+                sensitive_values: options.sensitiveValue,
+                ...(options.record === undefined
+                    ? {}
+                    : { record_ordinals: options.record }),
+            }, { signal });
+            return result.ok
+                ? result.value
+                : projectAnalysisError(result.error);
+        })),
+    });
+};

package/dist/cli/webRuntimeCommands.js

@@ -25,15 +25,15 @@ export const registerWebRuntimeCommands = (cli, logger) => {
             ...browserScopeOptions,
             observationMs: observationDuration(10_000, 1),
         }),
-        run: ({ args, options }) => logCliCommand(logger, "observe-web-execution", async () => {
-            const result = await withCommandCancellation((signal) => createWebRuntimeService().observe({
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, "observe-web-execution", async () => {
+            const result = await createWebRuntimeService().observe({
                 cdp_endpoint: args.endpoint,
                 target_id: args.targetId,
                 allowed_origins: options.allowedOrigins,
                 observation_ms: options.observationMs,
-            }, { progress: runtimeProgress, signal }));
+            }, { progress: runtimeProgress, signal });
             return result.ok ? result.value : browserCliError(result.error);
-        }),
+        })),
     });
     cli.command(CLI_COMMANDS.inspectWebEventListeners, {
         description: "Inspect native listener source locations on the first main-document CSS match",
@@ -47,14 +47,14 @@ export const registerWebRuntimeCommands = (cli, logger) => {
                 .describe("Native CSS selector; inspect the first main-document match"),
         }),
         options: z.object({ ...browserScopeOptions }),
-        run: ({ args, options }) => logCliCommand(logger, "inspect-web-event-listeners", async () => {
-            const result = await withCommandCancellation((signal) => createWebRuntimeService().inspect({
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, "inspect-web-event-listeners", async () => {
+            const result = await createWebRuntimeService().inspect({
                 cdp_endpoint: args.endpoint,
                 target_id: args.targetId,
                 selector: args.selector,
                 allowed_origins: options.allowedOrigins,
-            }, { signal }));
+            }, { signal });
             return result.ok ? result.value : browserCliError(result.error);
-        }),
+        })),
     });
 };

package/dist/cli.js

@@ -1,6 +1,9 @@
+import { registerEvmCommands } from "./cli/evmCommands.js";
+import { registerBinaryDiagnosticsCommands } from "./cli/binaryDiagnosticsCommands.js";
 import { Cli } from "incur";
 import { createLogger, parseLogLevel } from "./logger.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
+import { npxRegistrationCommand } from "./application/ClientRegistrationIdentity.js";
 import { registerSetupCommands } from "./cli/setupCommands.js";
 import { registerCoreAnalysisCommands } from "./cli/coreAnalysisCommands.js";
 import { registerUtilityCommands } from "./cli/utilityCommands.js";
@@ -15,6 +18,7 @@ import { registerWebScriptCommands } from "./cli/webScriptCommands.js";
 import { registerWebModuleCommands } from "./cli/webModuleCommands.js";
 import { registerWebSourceLocationCommands } from "./cli/webSourceLocationCommands.js";
 import { registerWebRuntimeCommands } from "./cli/webRuntimeCommands.js";
+import { registerWebNetworkCaptureCommands } from "./cli/webNetworkCaptureCommands.js";
 import { registerJavaScriptRecoveryCommands } from "./cli/javascriptRecoveryCommands.js";
 import { registerAdvancedBrowserCommands } from "./cli/browserAdvancedCommands.js";
 import { registerBrowserScenarioCommands } from "./cliBrowserScenarioCommands.js";
@@ -26,7 +30,7 @@ import { registerApplicationCommands } from "./cli/applicationCommands.js";
  * Analysis commands acquire and close their own sessions; bare `mcp` and
  * `--mcp` are intercepted by the executable dispatcher before this module loads.
  */
-export const createCli = (environment = process.env) => {
+export const createCli = (environment = process.env, resultOutput) => {
     const logger = createLogger("cli", environment.REA_LOG_LEVEL === undefined
         ? "silent"
         : parseLogLevel(environment.REA_LOG_LEVEL));
@@ -34,18 +38,20 @@ export const createCli = (environment = process.env) => {
         version: PRODUCT_IDENTITY.packageVersion,
         description: "Reverse engineer anything from your terminal or agent.",
         mcp: {
-            command: PRODUCT_IDENTITY.mcpCommand,
+            command: npxRegistrationCommand().join(" "),
             instructions: "Ask what software, artifact, protocol, or behavior the user wants to understand, then choose the available investigation capabilities that can produce evidence.",
         },
         sync: false,
     });
     registerSetupCommands(cli, logger);
-    registerCoreAnalysisCommands(cli, logger);
+    registerCoreAnalysisCommands(cli, logger, resultOutput);
     registerUtilityCommands(cli, logger, environment);
+    registerEvmCommands(cli, logger, environment);
     registerArtifactCommands(cli, logger);
     registerManagedCommands(cli, logger);
     registerAndroidCommands(cli, logger, environment);
     registerFirmwareCommands(cli, logger, environment);
+    registerBinaryDiagnosticsCommands(cli, logger, environment);
     registerEvidenceCommands(cli, logger);
     registerProcessCommands(cli, logger, environment);
     registerBrowserCommands(cli, logger);
@@ -53,10 +59,11 @@ export const createCli = (environment = process.env) => {
     registerWebModuleCommands(cli, logger, environment);
     registerWebSourceLocationCommands(cli, logger, environment);
     registerWebRuntimeCommands(cli, logger);
+    registerWebNetworkCaptureCommands(cli, logger, environment);
     registerJavaScriptRecoveryCommands(cli, logger, environment);
     registerAdvancedBrowserCommands(cli, logger);
     registerBrowserScenarioCommands(cli, logger);
-    registerElectronCommands(cli, logger);
+    registerElectronCommands(cli, logger, resultOutput);
     registerJavaScriptRuntimeObservationCommands(cli, logger);
     registerApplicationCommands(cli, logger);
     return cli;

package/dist/cliBrowserScenarioCommands.js

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { captureBrowserScenario } from "./application/BrowserScenarioCaptureService.js";
 import { createBrowserScenarioProvider } from "./composition/browserScenario.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
-import { parseCliJsonInput } from "./cliJsonInput.js";
+import { parseCliJsonInput, resolveCliJsonPaths } from "./cliJsonInput.js";
 import { logCliCommand } from "./cliLogging.js";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
@@ -23,7 +23,7 @@ export const registerBrowserScenarioCommands = (cli, logger) => {
             const input = await parseCliJsonInput(args.inputJson, OPERATION);
             if (!input.ok)
                 return input.error;
-            const scenario = browserScenarioSchema.safeParse(input.value);
+            const scenario = browserScenarioSchema.safeParse(resolveCliJsonPaths(input.value, [["browser", "executable_path"]]));
             if (!scenario.success)
                 return cliError(new AnalysisInputError(OPERATION, { cause: scenario.error }, projectInputIssues(scenario.error.issues, input.value)));
             const result = await captureBrowserScenario(createBrowserScenarioProvider(), scenario.data);

package/dist/cliCommandNames.js

@@ -1,5 +1,7 @@
 /** Canonical names used by every one-shot CLI command registration. */
 export const CLI_COMMANDS = Object.freeze({
+    inspectEvmInterface: "inspect-evm-interface",
+    inspectWebNetworkCapture: "inspect-web-network-capture",
     observeWebExecution: "observe-web-execution",
     inspectWebEventListeners: "inspect-web-event-listeners",
     traceWebSourceLocation: "trace-web-source-location",
@@ -27,6 +29,7 @@ export const CLI_COMMANDS = Object.freeze({
     extractArtifact: "extract-artifact",
     decodeInterfaceBuilder: "decode-interface-builder",
     inspectKeyedArchive: "inspect-keyed-archive",
+    traceDylibResolution: "trace-dylib-resolution",
     inspectNativeDataType: "inspect-native-data-type",
     inspectNativeLoadImage: "inspect-native-load-image",
     readBytes: "read-bytes",
@@ -36,6 +39,8 @@ export const CLI_COMMANDS = Object.freeze({
     resolveNativeCallTargets: "resolve-native-call-targets",
     inspectAssetCatalog: "inspect-asset-catalog",
     inspectManagedArtifact: "inspect-managed-artifact",
+    inspectRecordedCrash: "inspect-recorded-crash",
+    inspectBinaryLayout: "inspect-binary-layout",
     inspectFirmwareRegions: "inspect-firmware-regions",
     extractFirmware: "extract-firmware",
     inspectAndroidPackage: "inspect-android-package",
@@ -50,6 +55,7 @@ export const CLI_COMMANDS = Object.freeze({
     importManagedReconstruction: "import-managed-reconstruction",
     projectManagedApplicationGraph: "project-managed-application-graph",
     observeNativeUi: "observe-native-ui",
+    observeNativeCalls: "observe-native-calls",
     captureNativeUiScenario: "capture-native-ui-scenario",
     inspectMacho: "inspect-macho",
     inspectSignature: "inspect-signature",
@@ -133,7 +139,6 @@ export const MCP_TOOLS_WITHOUT_DEDICATED_CLI = Object.freeze([
     "set_addresses_names",
     "set_bookmark",
     "set_comment",
-    "set_current_document",
     "set_inline_comment",
     "unset_bookmark",
     "get_objc_classes",

package/dist/cliJsonInput.js

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { safeParseJson } from "./domain/safeJson.js";
@@ -23,10 +24,43 @@ export const parseCliJsonInput = async (value, operation) => {
         return jsonFileError(value, operation, "read-failed", cause);
     }
 };
+/**
+ * Resolve named string fields of CLI-supplied JSON against the operator
+ * working directory. Each entry is a key path from the document root; only
+ * fields holding nonblank strings are resolved, everything else passes through
+ * untouched so shared schemas can reject blank paths. Shared MCP contracts reject
+ * relative paths, so CLI workflows resolve operator-relative values before validation.
+ */
+export const resolveCliJsonPaths = (value, paths) => {
+    let resolved = value;
+    for (const keys of paths)
+        resolved = resolveJsonPath(resolved, keys);
+    return resolved;
+};
+const resolveJsonPath = (value, keys) => {
+    const [head, ...tail] = keys;
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return value;
+    const entries = Object.entries(value).map(([key, entry]) => {
+        if (key !== head)
+            return [key, entry];
+        if (tail.length === 0)
+            return [
+                key,
+                typeof entry === "string" && entry.trim().length > 0
+                    ? resolve(entry)
+                    : entry,
+            ];
+        return [key, resolveJsonPath(entry, tail)];
+    });
+    return Object.fromEntries(entries);
+};
 const cannotBeAnExistingFile = (cause) => typeof cause === "object" &&
     cause !== null &&
     "code" in cause &&
-    (cause.code === "ENOENT" || cause.code === "ENAMETOOLONG");
+    (cause.code === "ENOENT" ||
+        cause.code === "ENAMETOOLONG" ||
+        cause.code === "ENOTDIR");
 const hasExplicitJsonFileExtension = (value) => value.toLowerCase().endsWith(".json");
 const parseJson = (value) => {
     let text;

package/dist/cliOutput.js

@@ -10,10 +10,21 @@ const validationError = (value) => {
         return value.error.code === "VALIDATION_ERROR" ? value.error : undefined;
     return undefined;
 };
-const parseCliOutputArguments = (arguments_) => {
+/** Read effective Incur output controls at the executable boundary. */
+export const parseCliOutputArguments = (arguments_) => {
     let format = "toon";
-    let filterOutput = false;
+    let filterOutput;
+    let fullOutput = false;
+    let tokenCount = false;
     let tokenWindow = false;
+    const parsed = (parseError) => ({
+        filterOutput,
+        format,
+        fullOutput,
+        parseError,
+        tokenCount,
+        tokenWindow: parseError ? false : tokenWindow,
+    });
     for (let index = 0; index < arguments_.length; index += 1) {
         const argument = arguments_[index];
         // Incur scans builtins across `--` and accepts only spaced value forms.
@@ -28,7 +39,7 @@ const parseCliOutputArguments = (arguments_) => {
                 // Incur stops parsing at an invalid format before applying any later
                 // output controls. Let it report that malformed flag itself.
                 if (!INCUR_OUTPUT_FORMATS.has(value))
-                    return { filterOutput, format, parseError: true, tokenWindow: false };
+                    return parsed(true);
                 format = value;
                 index += 1;
             }
@@ -36,7 +47,7 @@ const parseCliOutputArguments = (arguments_) => {
         }
         if (argument === "--filter-output") {
             if (arguments_[index + 1]) {
-                filterOutput = true;
+                filterOutput = arguments_[index + 1];
                 index += 1;
             }
             continue;
@@ -46,14 +57,18 @@ const parseCliOutputArguments = (arguments_) => {
             if (value) {
                 const numericValue = Number(value);
                 if (!Number.isFinite(numericValue) || value.trim() === "")
-                    return { filterOutput, format, parseError: true, tokenWindow: false };
+                    return parsed(true);
                 tokenWindow = true;
                 index += 1;
             }
             continue;
         }
+        if (argument === "--full-output")
+            fullOutput = true;
+        if (argument === "--token-count")
+            tokenCount = true;
     }
-    return { filterOutput, format, parseError: false, tokenWindow };
+    return parsed(false);
 };
 /** Reject text-window controls that would corrupt a structured document. */
 export const validateCliOutputArguments = (arguments_) => {

package/dist/composition/binaryDiagnostics.js

@@ -0,0 +1,8 @@
+import { RecordedCrashService } from "../application/binaryDiagnostics/RecordedCrashService.js";
+import { PwntoolsRecordedCrashProvider } from "../native/pwntools/PwntoolsRecordedCrashProvider.js";
+import { BinaryLayoutService } from "../application/binaryDiagnostics/BinaryLayoutService.js";
+import { PwntoolsLayoutProvider } from "../native/pwntools/PwntoolsLayoutProvider.js";
+/** Compose the offline adapter without import-time I/O or dependency acquisition. */
+export const createBinaryLayoutService = (environment = process.env) => new BinaryLayoutService(new PwntoolsLayoutProvider(environment));
+/** Compose recorded-core inspection without acquiring a debugger or toolchain. */
+export const createRecordedCrashService = (environment = process.env) => new RecordedCrashService(new PwntoolsRecordedCrashProvider(environment));

package/dist/composition/evm.js

@@ -0,0 +1,4 @@
+import { EvmInterfaceService } from "../application/evm/EvmInterfaceService.js";
+import { EvmoleInterfaceProvider } from "../evm/EvmoleInterfaceProvider.js";
+/** Compose offline interface analysis without import-time I/O or dependency acquisition. */
+export const createEvmInterfaceService = (environment = process.env) => new EvmInterfaceService(new EvmoleInterfaceProvider(environment));