rea-agents 6.3.0 → 6.5.0

package/dist/cli-runtime/workflowInputError-n8Oo-bLA.js

@@ -0,0 +1,26 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { analysisInputErrorFromIssues, init_inputIssueProjection } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
+import { AnalysisInputError, init_analysisErrorCore } from "./errorSchemas-CTRmvMl3.js";
+import { z } from "zod";
+
+//#region dist/application/workflowInputError.js
+var requestInputError, workflowInputError;
+function init_workflowInputError() {
+	return (init_workflowInputError = __esmMin((() => {
+		init_analysisErrorCore();
+		init_inputIssueProjection();
+		requestInputError = (operation, cause, input) => analysisInputErrorFromIssues(operation, cause.issues, input, { cause });
+		workflowInputError = (operation, cause) => new AnalysisInputError(operation, { cause }, cause instanceof z.ZodError ? cause.issues.map((issue) => ({
+			path: [],
+			reason: "invalid_value",
+			message: `A nested value failed validation at ${issue.path.length === 0 ? "its root" : issue.path.map(String).join(".")}: ${issue.message}`
+		})) : [{
+			path: [],
+			reason: "invalid_value",
+			message: cause.message
+		}]);
+	})))();
+}
+
+//#endregion
+export { init_workflowInputError, requestInputError, workflowInputError };

package/dist/cli.js

@@ -1,10 +1,18 @@
+import { registerCaptureCommands } from "./cli/captureCommands.js";
+import { registerSignalCommands } from "./cli/signalCommands.js";
+import { registerWasmCommands } from "./cli/wasmCommands.js";
 import { snapshotEnvironment } from "./process/snapshotEnvironment.js";
 import { createDirectAnalysis } from "./composition/directAnalysis.js";
 import { registerEvmCommands } from "./cli/evmCommands.js";
+import { registerGoCommands } from "./cli/goCommands.js";
+import { registerRustCommands } from "./cli/rustCommands.js";
+import { registerSqliteCommands } from "./cli/sqliteCommands.js";
 import { registerAnalysisViewCommands } from "./cli/analysisViewCommands.js";
 import { registerBinaryDiagnosticsCommands } from "./cli/binaryDiagnosticsCommands.js";
+import { registerFridaCommands } from "./cli/fridaCommands.js";
 import { Cli } from "incur";
 import { createLogger, parseLogLevel } from "./logger.js";
+import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
 import { npxRegistrationCommand } from "./application/ClientRegistrationIdentity.js";
 import { registerSetupCommands } from "./cli/setupCommands.js";
@@ -14,6 +22,11 @@ import { registerArtifactCommands } from "./cli/artifactCommands.js";
 import { registerManagedCommands } from "./cli/managedCommands.js";
 import { registerFirmwareCommands } from "./cli/firmwareCommands.js";
 import { registerAndroidCommands } from "./cli/androidCommands.js";
+import { registerApktoolCommands } from "./cli/apktoolCommands.js";
+import { registerPcapCommands } from "./cli/pcapCommands.js";
+import { registerFlutterCommands } from "./cli/flutterCommands.js";
+import { registerJebCommands } from "./cli/jebCommands.js";
+import { registerAdbCommands } from "./cli/adbCommands.js";
 import { registerEvidenceCommands } from "./cliEvidenceCommands.js";
 import { registerProcessCommands } from "./cli/processCommands.js";
 import { registerBrowserCommands } from "./cli/browserCommands.js";
@@ -29,18 +42,30 @@ import { registerElectronCommands } from "./cli/electronCommands.js";
 import { registerJavaScriptRuntimeObservationCommands } from "./cliJavaScriptRuntimeCommands.js";
 import { registerApplicationCommands } from "./cli/applicationCommands.js";
 import { presentOmittableDefaults } from "./cli/omittableDefaults.js";
-import { streamCliCommandResults, } from "./cli/streamedJsonOutput.js";
+import { streamCliCommandResults, } from "./cli/cliResultOutput.js";
+import { registerReverseEngineeringCommands } from "./cli/reverseEngineeringCommands.js";
+import { registerCutterCommands } from "./cli/cutterCommands.js";
+/** Describe CLI settings that are invalid before any command runs, as MCP does. */
+export const cliConfigurationError = (selectedEnvironment) => {
+    const value = selectedEnvironment.REA_LOG_LEVEL;
+    if (value === undefined)
+        return undefined;
+    const level = parseLogLevel(value);
+    return level.ok ? undefined : projectAnalysisError(level.error).message;
+};
 /**
  * Build the one-shot Incur CLI without starting Hopper at import time.
  * 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 = (selectedEnvironment = process.env, resultOutput) => {
+export const createCli = (selectedEnvironment = process.env, resultOutput, fridaInstrumentation) => {
     const environment = snapshotEnvironment(selectedEnvironment);
     const analysis = createDirectAnalysis(environment);
-    const logger = createLogger("cli", environment.REA_LOG_LEVEL === undefined
-        ? "silent"
-        : parseLogLevel(environment.REA_LOG_LEVEL));
+    // The executable reports an invalid level through cliConfigurationError.
+    const level = environment.REA_LOG_LEVEL === undefined
+        ? undefined
+        : parseLogLevel(environment.REA_LOG_LEVEL);
+    const logger = createLogger("cli", level?.ok === true ? level.value : "silent");
     const cli = Cli.create(PRODUCT_IDENTITY.cliBinary, {
         version: PRODUCT_IDENTITY.packageVersion,
         description: "Reverse engineer anything from your terminal or agent.",
@@ -51,15 +76,29 @@ export const createCli = (selectedEnvironment = process.env, resultOutput) => {
         sync: false,
     });
     registerSetupCommands(cli, logger, environment);
+    registerReverseEngineeringCommands(cli, logger, environment);
+    registerCutterCommands(cli, logger, environment);
     registerCoreAnalysisCommands(cli, logger, analysis.runDirectAnalysis);
     registerUtilityCommands(cli, logger, environment, analysis);
+    registerWasmCommands(cli, logger, environment);
+    registerCaptureCommands(cli, logger, environment);
+    registerSignalCommands(cli, logger, environment);
     registerEvmCommands(cli, logger, environment);
+    registerGoCommands(cli, logger);
+    registerRustCommands(cli, logger);
+    registerSqliteCommands(cli, logger, environment);
     registerArtifactCommands(cli, logger, analysis.runProviderAnalysis);
     registerManagedCommands(cli, logger, analysis.runProviderAnalysis);
     registerAndroidCommands(cli, logger, environment);
+    registerApktoolCommands(cli, logger, environment);
+    registerPcapCommands(cli, logger, environment);
+    registerFlutterCommands(cli, logger);
+    registerJebCommands(cli, logger, environment);
+    registerAdbCommands(cli, logger, environment);
     registerFirmwareCommands(cli, logger, environment);
     registerBinaryDiagnosticsCommands(cli, logger, environment);
     registerAnalysisViewCommands(cli, logger);
+    registerFridaCommands(cli, logger, fridaInstrumentation);
     registerEvidenceCommands(cli, logger);
     registerProcessCommands(cli, logger, environment);
     registerBrowserCommands(cli, logger);

package/dist/cliBrowserScenarioCommands.js

@@ -1,12 +1,14 @@
 import { Cli } from "incur";
 import { z } from "zod";
 import { captureBrowserScenario } from "./application/BrowserScenarioCaptureService.js";
-import { createBrowserScenarioProvider } from "./composition/browserScenario.js";
+import { withCommandCancellation } from "./cli/commandCancellation.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { parseCliJsonInput, resolveCliJsonPaths } from "./cliJsonInput.js";
 import { logCliCommand } from "./cliLogging.js";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
+import { AnalysisError } from "./domain/analysisErrorBase.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
+import { BrowserObservationError } from "./domain/browserObservationError.js";
 import { projectInputIssues } from "./domain/inputIssueProjection.js";
 import { browserScenarioSchema } from "./domain/browserScenario.js";
 const OPERATION = "capture_browser_scenario";
@@ -19,16 +21,50 @@ export const registerBrowserScenarioCommands = (cli, logger, environment) => {
                 .string()
                 .describe("Inline browser scenario JSON or JSON file path"),
         }),
-        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.captureBrowserScenario, async () => {
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.captureBrowserScenario, async () => {
             const input = await parseCliJsonInput(args.inputJson, OPERATION);
             if (!input.ok)
                 return input.error;
             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(environment), scenario.data);
-            return result.ok ? result.value : cliError(result.error);
-        }),
+            // Load Playwright only for this command, not during CLI startup.
+            const { createBrowserScenarioProvider } = await import("./composition/browserScenario.js");
+            const provider = createBrowserScenarioProvider(environment);
+            let result;
+            try {
+                result = await captureBrowserScenario(provider, scenario.data, {
+                    signal,
+                });
+                return result.ok ? result.value : cliError(result.error);
+            }
+            finally {
+                try {
+                    await provider?.close?.();
+                }
+                catch (cause) {
+                    // Failed captures already retain their primary error and partial
+                    // observations. A cleanup retry must not replace that outcome.
+                    if (result?.ok)
+                        throw new BrowserObservationError(OPERATION, "cleanup_failed", {
+                            cause,
+                            cleanup: cause instanceof AnalysisError &&
+                                cause.cleanup !== undefined
+                                ? cause.cleanup
+                                : {
+                                    reason: cause instanceof Error
+                                        ? cause.message
+                                        : String(cause),
+                                    resources: cause instanceof AnalysisError &&
+                                        cause.cleanupResources.length > 0
+                                        ? cause.cleanupResources
+                                        : ["browser_transport"],
+                                },
+                            partialObservation: result.value,
+                        });
+                }
+            }
+        })),
     });
 };
 const cliError = (error) => ({

package/dist/cliCommandNames.js

@@ -1,5 +1,12 @@
 /** Canonical names used by every one-shot CLI command registration. */
 export const CLI_COMMANDS = Object.freeze({
+    inspectPacketFields: "inspect-packet-fields",
+    inspectPacketCapture: "inspect-packet-capture",
+    inspectSignalDecoders: "inspect-signal-decoders",
+    decodeSignalRecording: "decode-signal-recording",
+    compareWasmInterfaces: "compare-wasm-interfaces",
+    inspectWasmArtifact: "inspect-wasm-artifact",
+    inspectSqliteDatabase: "inspect-sqlite-database",
     inspectEvmInterface: "inspect-evm-interface",
     inspectWebNetworkCapture: "inspect-web-network-capture",
     observeWebExecution: "observe-web-execution",
@@ -33,6 +40,7 @@ export const CLI_COMMANDS = Object.freeze({
     inspectNativeDataType: "inspect-native-data-type",
     inspectNativeLoadImage: "inspect-native-load-image",
     readBytes: "read-bytes",
+    searchBytes: "search-bytes",
     addressToFileOffset: "address-to-file-offset",
     traceNativeValues: "trace-native-values",
     inspectNativeInstruction: "inspect-native-instruction",
@@ -41,14 +49,62 @@ export const CLI_COMMANDS = Object.freeze({
     inspectManagedArtifact: "inspect-managed-artifact",
     inspectRecordedCrash: "inspect-recorded-crash",
     inspectBinaryLayout: "inspect-binary-layout",
+    listCutterSessions: "list-cutter-sessions",
+    cutterCommand: "cutter-command",
+    inspectWithObjdump: "inspect-with-objdump",
+    listObjdumpArchitectures: "list-objdump-architectures",
+    executeRizinCommand: "execute-rizin-command",
+    debugWithGdb: "debug-with-gdb",
+    debugWithRizin: "debug-with-rizin",
+    inspectGoBinary: "inspect-go-binary",
+    inspectRustBinary: "inspect-rust-binary",
+    inspectPeResources: "inspect-pe-resources",
     inspectAnalysisView: "inspect-analysis-view",
+    listFridaDevices: "list-frida-devices",
+    listFridaProcesses: "list-frida-processes",
+    instrumentWithFrida: "instrument-with-frida",
+    inspectEvidenceBundle: "inspect-evidence-bundle",
     inspectFirmwareRegions: "inspect-firmware-regions",
     extractFirmware: "extract-firmware",
     inspectAndroidPackage: "inspect-android-package",
+    inspectPcapClient: "inspect-pcap-client",
+    inspectPcapCapture: "inspect-pcap-capture",
+    identifyFlutterBuild: "identify-flutter-build",
+    inspectDartAot: "inspect-dart-aot",
+    inspectApktoolClient: "inspect-apktool-client",
+    decodeAndroidResources: "decode-android-resources",
+    inspectAdbClient: "inspect-adb-client",
+    listAdbDevices: "list-adb-devices",
+    inspectAdbDevice: "inspect-adb-device",
+    listAdbPackages: "list-adb-packages",
+    pullAdbPackage: "pull-adb-package",
+    readAdbLogcat: "read-adb-logcat",
+    inspectAdbPackage: "inspect-adb-package",
+    pullAdbFile: "pull-adb-file",
+    pushAdbFile: "push-adb-file",
+    captureAdbScreen: "capture-adb-screen",
+    listAdbProcesses: "list-adb-processes",
+    listAdbDirectory: "list-adb-directory",
+    listAdbFeatures: "list-adb-features",
+    listAdbServices: "list-adb-services",
+    inspectAdbDisplay: "inspect-adb-display",
+    inspectAdbWindow: "inspect-adb-window",
+    readAdbSetting: "read-adb-setting",
+    collectAdbBugreport: "collect-adb-bugreport",
+    resolveAdbPackages: "resolve-adb-packages",
+    installAdbPackage: "install-adb-package",
+    uninstallAdbPackage: "uninstall-adb-package",
+    startAdbApp: "start-adb-app",
+    startAdbActivity: "start-adb-activity",
+    stopAdbApp: "stop-adb-app",
     searchAndroidClasses: "search-android-classes",
     inspectAndroidClass: "inspect-android-class",
     inspectAndroidMethod: "inspect-android-method",
     traceAndroidReferences: "trace-android-references",
+    inspectJebClient: "inspect-jeb-client",
+    openJebProject: "open-jeb-project",
+    listJebUnits: "list-jeb-units",
+    decompileJebItem: "decompile-jeb-item",
     inspectManagedMembers: "inspect-managed-members",
     inspectManagedNativeBoundaries: "inspect-managed-native-boundaries",
     compareManagedMembers: "compare-managed-members",
@@ -81,6 +137,7 @@ export const CLI_COMMANDS = Object.freeze({
     captureBrowserScenario: "capture-browser-scenario",
     listElectronTargets: "list-electron-targets",
     inspectElectronPage: "inspect-electron-page",
+    inspectElectronFuses: "inspect-electron-fuses",
     captureElectronScenario: "capture-electron-scenario",
     listJavaScriptRuntimeTargets: "list-javascript-runtime-targets",
     observeJavaScriptRuntime: "observe-javascript-runtime",
@@ -95,6 +152,7 @@ export const CLI_COMMANDS = Object.freeze({
     evaluateReconstructionCoverage: "evaluate-reconstruction-coverage",
     projectAndroidApplicationGraph: "project-android-application-graph",
     projectAppleApplicationGraph: "project-apple-application-graph",
+    projectHarmonyApplicationGraph: "project-harmony-application-graph",
 });
 /** Ordered primary CLI inventory; aliases are intentionally excluded. */
 export const CLI_COMMAND_NAMES = Object.freeze(Object.values(CLI_COMMANDS));
@@ -111,6 +169,16 @@ export const CLI_COMMAND_TOOL_ALIASES = Object.freeze({
     search: ["search_strings", "search_procedures"],
     "capture-process": ["capture_process_scenario"],
     "compare-bundles": ["compare_bundles"],
+    "list-cutter-sessions": ["list_cutter_sessions"],
+    "cutter-command": ["cutter_command"],
+    "inspect-with-objdump": ["inspect_with_objdump"],
+    "list-objdump-architectures": ["inspect_with_objdump"],
+    "execute-rizin-command": ["execute_rizin_command"],
+    "debug-with-gdb": ["gdb_console"],
+    "debug-with-rizin": ["rizin_debug_command"],
+    "list-frida-devices": ["list_frida_devices"],
+    "list-frida-processes": ["list_frida_processes"],
+    "instrument-with-frida": ["instrument_with_frida"],
 });
 /** MCP operations without a dedicated CLI command or direct command alias. */
 export const MCP_TOOLS_WITHOUT_DEDICATED_CLI = Object.freeze([
@@ -167,4 +235,16 @@ export const MCP_TOOLS_WITHOUT_DEDICATED_CLI = Object.freeze([
     "get_evidence_bundle",
     "get_navigation_context",
     "inspect_address_context",
+    "start_gdb_session",
+    "gdb_session_status",
+    "close_gdb_session",
+    "start_rizin_debug_session",
+    "rizin_debug_session_status",
+    "close_rizin_debug_session",
+    "start_frida_session",
+    "load_frida_script",
+    "resume_frida_session",
+    "unload_frida_script",
+    "frida_session_status",
+    "close_frida_session",
 ]);

package/dist/cliEvidenceCommands.js

@@ -3,7 +3,6 @@ import { compareEvidenceBundlesCommand, exportEvidenceBundleCommand, importEvide
 import { logCliCommand } from "./cliLogging.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
-import {} from "./domain/analysisErrorBase.js";
 /** Register caller-path Evidence commands. */
 export const registerEvidenceCommands = (cli, logger) => {
     cli.command(CLI_COMMANDS.evidenceImport, {

package/dist/cliJavaScriptRuntimeCommands.js

@@ -4,8 +4,9 @@ import { createJavaScriptRuntimeObservationProvider } from "./composition/javasc
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { logCliCommand } from "./cliLogging.js";
 import { javascriptRuntimeKindSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "./domain/javascript/javascriptRuntimeObservation.js";
-import { AnalysisInputError } from "./domain/analysisErrorCore.js";
+import { analysisInputErrorFromIssues } from "./domain/inputIssueProjection.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./cli/commandCancellation.js";
 const observeOptionsSchema = z.object({
     runtimeKind: javascriptRuntimeKindSchema
         .optional()
@@ -24,16 +25,17 @@ export const registerJavaScriptRuntimeObservationCommands = (cli, logger) => {
         args: z.object({
             endpoint: z.string().describe("Literal-loopback Inspector endpoint"),
         }),
-        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.listJavaScriptRuntimeTargets, async () => {
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.listJavaScriptRuntimeTargets, async () => {
             const context = runtimeContext();
-            const parsed = listJavaScriptRuntimeTargetsInputSchema.safeParse({
+            const input = {
                 inspector_endpoint: args.endpoint,
-            });
+            };
+            const parsed = listJavaScriptRuntimeTargetsInputSchema.safeParse(input);
             if (!parsed.success)
-                return inputError("list_javascript_runtime_targets");
-            const result = await listJavaScriptRuntimeTargets(context.provider, parsed.data);
+                return cliError(analysisInputErrorFromIssues("list_javascript_runtime_targets", parsed.error.issues, input));
+            const result = await listJavaScriptRuntimeTargets(context.provider, parsed.data, { signal });
             return result.ok ? result.value : cliError(result.error);
-        }),
+        })),
     });
     cli.command(CLI_COMMANDS.observeJavaScriptRuntime, {
         description: "Passively observe one exact Node/Electron Inspector target",
@@ -44,25 +46,25 @@ export const registerJavaScriptRuntimeObservationCommands = (cli, logger) => {
                 .describe("Target from list-javascript-runtime-targets"),
         }),
         options: observeOptionsSchema,
-        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.observeJavaScriptRuntime, async () => {
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.observeJavaScriptRuntime, async () => {
             const context = runtimeContext();
-            const parsed = observeJavaScriptRuntimeInputSchema.safeParse({
+            const input = {
                 inspector_endpoint: args.endpoint,
                 target_id: args.targetId,
                 runtime_kind: options.runtimeKind,
                 observation_ms: options.observationMs,
-            });
+            };
+            const parsed = observeJavaScriptRuntimeInputSchema.safeParse(input);
             if (!parsed.success)
-                return inputError("observe_javascript_runtime");
-            const result = await observeJavaScriptRuntime(context.provider, parsed.data);
+                return cliError(analysisInputErrorFromIssues("observe_javascript_runtime", parsed.error.issues, input));
+            const result = await observeJavaScriptRuntime(context.provider, parsed.data, { signal });
             return result.ok ? result.value : cliError(result.error);
-        }),
+        })),
     });
 };
 const runtimeContext = () => ({
     provider: createJavaScriptRuntimeObservationProvider(),
 });
-const inputError = (operation) => cliError(new AnalysisInputError(operation));
 const cliError = (error) => ({
     error: "JavaScript runtime observation failed",
     ...projectAnalysisError(error),

package/dist/cliJsonInput.js

@@ -1,5 +1,5 @@
 import { resolve } from "node:path";
-import { readCliJsonFile } from "./cliJsonFile.js";
+import { readJsonInputFile } from "./application/JsonInputFile.js";
 import { NonRegularFileReadError } from "./filesystem/RegularFile.js";
 import { AnalysisAccessDeniedError, AnalysisInputError, } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
@@ -10,7 +10,7 @@ export const parseCliJsonInput = async (value, operation) => {
     if (inline.ok)
         return { ok: true, value: inline.value };
     try {
-        const parsed = await readCliJsonFile(value, operation);
+        const parsed = await readJsonInputFile(value, operation);
         return parsed.ok
             ? { ok: true, value: parsed.value }
             : {
@@ -47,12 +47,18 @@ const accessDeniedSystemCode = (cause) => {
         ? cause.code
         : undefined;
 };
+/**
+ * A `file:` URL or `scheme://` URL is not an operator-relative filesystem path.
+ * One-letter prefixes stay paths so Windows drive paths resolve normally.
+ */
+const URL_REFERENCE = /^(?:file:|[A-Za-z][A-Za-z0-9+.-]+:\/\/)/iu;
 /**
  * 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.
+ * fields holding nonblank, non-URL strings are resolved, everything else passes
+ * through untouched so shared schemas can reject blank paths and URLs. Shared MCP
+ * contracts reject relative paths, so CLI workflows resolve operator-relative
+ * values before validation.
  */
 export const resolveCliJsonPaths = (value, paths) => {
     let resolved = value;
@@ -70,7 +76,9 @@ const resolveJsonPath = (value, keys) => {
         if (tail.length === 0)
             return [
                 key,
-                typeof entry === "string" && entry.trim().length > 0
+                typeof entry === "string" &&
+                    entry.trim().length > 0 &&
+                    !URL_REFERENCE.test(entry)
                     ? resolve(entry)
                     : entry,
             ];

package/dist/cliLogging.js

@@ -2,27 +2,63 @@ import { analysisCliErrorEnvelopeSchema, analysisErrorProjectionSchema, } from "
 import { AnalysisError } from "./domain/analysisErrorBase.js";
 import { projectAnalysisError, } from "./domain/analysisErrorProjection.js";
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-/** Identify caller-visible CLI outcomes that mean the requested operation failed. */
-export const isCliOperationFailure = (value) => {
+const loggedFailures = new WeakMap();
+/** Return the canonical failure projection owned by the CLI result boundary. */
+const projectCliOperationFailure = (value) => {
     if (!isRecord(value))
-        return false;
-    if (isRecord(value.error) &&
-        analysisErrorProjectionSchema.safeParse(value.error).success)
-        return true;
-    if (analysisCliErrorEnvelopeSchema.safeParse(value).success)
-        return true;
-    if (analysisErrorProjectionSchema.safeParse(value).success)
-        return true;
-    if (value.healthy === false)
-        return true;
-    return false;
+        return undefined;
+    const direct = analysisErrorProjectionSchema.safeParse(value);
+    if (direct.success)
+        return value;
+    const envelope = analysisCliErrorEnvelopeSchema.safeParse(value);
+    if (envelope.success) {
+        const { error: _label, input_path: inputPath, input_reason: inputReason, ...projection } = value;
+        const parsed = projection;
+        if (typeof inputPath !== "string" && typeof inputReason !== "string")
+            return parsed;
+        return {
+            ...parsed,
+            details: {
+                ...parsed.details,
+                ...(typeof inputPath === "string" ? { input_path: inputPath } : {}),
+                ...(typeof inputReason === "string"
+                    ? { input_reason: inputReason }
+                    : {}),
+            },
+        };
+    }
+    if (isRecord(value.error)) {
+        const nested = analysisErrorProjectionSchema.safeParse(value.error);
+        if (nested.success)
+            return value.error;
+    }
+    return undefined;
 };
+/** Return the canonical projection or original record classified as failed. */
+const inferCliOperationFailure = (value) => {
+    const projection = projectCliOperationFailure(value);
+    if (projection !== undefined)
+        return projection;
+    if (isRecord(value) && value.healthy === false)
+        return value;
+    return undefined;
+};
+export const cliOperationFailurePayload = (value) => {
+    if (isRecord(value) && loggedFailures.has(value))
+        return loggedFailures.get(value);
+    return inferCliOperationFailure(value);
+};
+/** Identify caller-visible CLI outcomes that mean the requested operation failed. */
+export const isCliOperationFailure = (value) => cliOperationFailurePayload(value) !== undefined;
 /** Log one CLI command with duration and a stable success or failure status. */
 export const logCliCommand = async (logger, command, execute, isCommandFailure) => {
     const startedAt = performance.now();
     try {
         const value = await execute();
-        const failed = isCommandFailure?.(value) ?? isCliOperationFailure(value);
+        const inferredFailure = inferCliOperationFailure(value);
+        const failed = isCommandFailure?.(value) ?? inferredFailure !== undefined;
+        if (isRecord(value))
+            loggedFailures.set(value, failed ? (inferredFailure ?? value) : undefined);
         logger[failed ? "error" : "info"]({
             command,
             durationMs: Math.round((performance.now() - startedAt) * 100) / 100,

package/dist/cliObservationOptions.js

@@ -1,4 +1,6 @@
 import { z } from "incur";
+import { javaScriptAnalysisResourceControlsSchema } from "./domain/javascript/javascriptAnalysisResourceControls.js";
+import { javaScriptSourcePathsSchema } from "./domain/javascript/javascriptSourceSelection.js";
 /** Accept an agent-selected browser observation duration without an artificial ceiling. */
 export const observationDuration = (fallback, minimum = 0) => z
     .number()
@@ -53,6 +55,13 @@ export const electronPageInspectionOptions = z.object({
         .describe("Include JavaScript source text"),
 });
 export const javascriptApplicationOptions = z.object({
+    maxSemanticNodes: javaScriptAnalysisResourceControlsSchema.shape.max_semantic_nodes,
+    maxSemanticNodesPerFile: javaScriptAnalysisResourceControlsSchema.shape.max_semantic_nodes_per_file,
+    sourcePath: javaScriptSourcePathsSchema
+        .optional()
+        .describe("Exact inventoried file path relative to the application root; repeat to select several. No implicit dependencies."),
+    maxHeapMb: javaScriptAnalysisResourceControlsSchema.shape.max_heap_mb,
+    analysisTimeoutMs: javaScriptAnalysisResourceControlsSchema.shape.analysis_timeout_ms,
     artifactFormat: z
         .enum(["auto", "asar", "directory"])
         .default("auto")

package/dist/cliOutput.js

@@ -6,14 +6,17 @@ export const parseCliOutputArguments = (arguments_) => {
     let filterOutput;
     let fullOutput = false;
     let tokenCount = false;
-    let tokenWindow = false;
+    let tokenLimit;
+    let tokenOffset;
     const parsed = (parseError) => ({
         filterOutput,
         format,
         fullOutput,
         parseError,
         tokenCount,
-        tokenWindow: parseError ? false : tokenWindow,
+        tokenWindow: !parseError && (tokenLimit !== undefined || tokenOffset !== undefined),
+        tokenLimit: parseError ? undefined : tokenLimit,
+        tokenOffset: parseError ? undefined : tokenOffset,
     });
     for (let index = 0; index < arguments_.length; index += 1) {
         const argument = arguments_[index];
@@ -48,7 +51,10 @@ export const parseCliOutputArguments = (arguments_) => {
                 const numericValue = Number(value);
                 if (!Number.isFinite(numericValue) || value.trim() === "")
                     return parsed(true);
-                tokenWindow = true;
+                if (argument === "--token-limit")
+                    tokenLimit = numericValue;
+                else
+                    tokenOffset = numericValue;
                 index += 1;
             }
             continue;
@@ -60,11 +66,38 @@ export const parseCliOutputArguments = (arguments_) => {
     }
     return parsed(false);
 };
-/** Reject text-window controls that would corrupt a structured document. */
+/** Reject slices that cannot advance within Incur's comma-delimited paths. */
+const hasUnclosedFilterSlice = (expression) => {
+    let depth = 0;
+    let unclosed = false;
+    for (const character of expression) {
+        if (character === "[") {
+            depth += 1;
+            unclosed = true;
+        }
+        else if (character === "]") {
+            depth -= 1;
+            // Incur consumes everything through the next closing bracket, including
+            // nested opening brackets. Do not impose a different filter grammar.
+            unclosed = false;
+        }
+        else if (character === "," && depth === 0 && unclosed)
+            return true;
+    }
+    return unclosed;
+};
+/** Reject output controls that cannot safely produce a complete result. */
 export const validateCliOutputArguments = (arguments_) => {
-    const { format, parseError, tokenWindow } = parseCliOutputArguments(arguments_);
+    const { filterOutput, format, parseError, tokenWindow } = parseCliOutputArguments(arguments_);
     if (parseError)
         return { ok: true };
+    if (filterOutput !== undefined && hasUnclosedFilterSlice(filterOutput))
+        return {
+            ok: false,
+            format: format === "yaml" || format === "jsonl" ? format : "json",
+            code: "INVALID_OUTPUT_FILTER",
+            message: "The --filter-output expression has a slice without a closing ]. Close the slice or remove --filter-output.",
+        };
     if (tokenWindow &&
         (format === "json" || format === "jsonl" || format === "yaml"))
         return {

package/dist/composition/adb.js

@@ -0,0 +1,3 @@
+import { AdbProvider } from "../adb/AdbProvider.js";
+/** Construct one ADB provider bound to the caller-selected binary. */
+export const createAdbDeviceAnalysisProvider = (environment = process.env) => new AdbProvider({ environment });

package/dist/composition/apktool.js

@@ -0,0 +1,3 @@
+import { ApktoolProvider } from "../apktool/ApktoolProvider.js";
+/** Construct one Apktool provider bound to the caller-selected launcher. */
+export const createApktoolResourceAnalysisProvider = (environment = process.env) => new ApktoolProvider({ environment });

package/dist/composition/binary.js

@@ -23,3 +23,7 @@ export const createBinarySession = (config, logger, selectedEnvironment) => {
 export const createManagedBinarySession = () => composeBinarySession(new AnalysisProviderRegistry([]), [
     new ManagedStaticProvider(),
 ]);
+/** Compose the artifact operations without candidates for deep analysis engines. */
+export const createArtifactBinarySession = (selectedEnvironment, platform = process.platform) => import("../artifacts/ArtifactProvider.js").then(({ ArtifactProvider }) => composeBinarySession(new AnalysisProviderRegistry([]), [
+    new ArtifactProvider(snapshotEnvironment(selectedEnvironment, platform), platform),
+]));