rea-agents 4.0.0 → 4.1.0

package/dist/cli/coreAnalysisCommands.js

@@ -4,10 +4,50 @@ import { resolve } from "node:path";
 import { runDirectAnalysis } from "../application/DirectAnalysis.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
-import { directAnalysisOptions, providerSelectionOption } from "./options.js";
+import { directAnalysisOptions, formatSelectionOption, providerSelectionOption, } from "./options.js";
 import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 export const registerCoreAnalysisCommands = (cli, logger) => {
     registerCoreCommands(cli, logger);
+    registerAnnotationCommand(cli, logger);
+    cli.command(CLI_COMMANDS.inspectNativeLoadImage, {
+        description: "Verify loaded native bytes, source mappings, relocations and entry",
+        args: z.object({ path: z.string().describe("Local executable path") }),
+        options: z.object({
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.inspectNativeLoadImage, () => runDirectAnalysis(args.path, "inspect_native_load_image", {}, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+    cli.command(CLI_COMMANDS.readBytes, {
+        description: "Read exact provider memory bytes at one analysis address",
+        args: z.object({
+            path: z.string().describe("Local executable path"),
+            address: z.string().describe("Exact provider memory address"),
+        }),
+        options: z.object({
+            length: z
+                .number()
+                .int()
+                .min(1)
+                .default(256)
+                .describe("Requested byte count"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.readBytes, () => runDirectAnalysis(args.path, "read_bytes", { address: args.address, length: options.length }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
+    cli.command(CLI_COMMANDS.addressToFileOffset, {
+        description: "Resolve an analysis address to its original file byte offset",
+        args: z.object({
+            path: z.string().describe("Local executable path"),
+            address: z.string().describe("Exact provider memory address"),
+        }),
+        options: z.object({
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.addressToFileOffset, () => runDirectAnalysis(args.path, "address_to_file_offset", { address: args.address }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
+    });
     cli.command(CLI_COMMANDS.traceNativeValues, {
         description: "Trace bounded native def-use and call dependencies",
         args: z.object({
@@ -65,6 +105,7 @@ export const registerCoreAnalysisCommands = (cli, logger) => {
                 .max(5000)
                 .default(1000)
                 .describe("Maximum nodes on this page"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
         alias: {
@@ -83,7 +124,7 @@ export const registerCoreAnalysisCommands = (cli, logger) => {
             max_edges: options.maxEdges,
             offset: options.offset,
             limit: options.limit,
-        }, directAnalysisOptions(logger, undefined, options.provider))),
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
     });
     cli.command(CLI_COMMANDS.inspectNativeDataType, {
         description: "Inspect one recovered database type or typed data object",
@@ -93,6 +134,7 @@ export const registerCoreAnalysisCommands = (cli, logger) => {
         options: z.object({
             type: z.string().optional().describe("Exact database type category path"),
             address: z.string().describe("Exact native address").optional(),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
         run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.inspectNativeDataType, () => runDirectAnalysis(args.path, "inspect_native_data_type", {
@@ -100,7 +142,7 @@ export const registerCoreAnalysisCommands = (cli, logger) => {
             ...(options.address === undefined
                 ? {}
                 : { address: options.address }),
-        }, directAnalysisOptions(logger, undefined, options.provider))),
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
     });
     for (const [command, operation] of [
         [CLI_COMMANDS.inspectNativeInstruction, "inspect_native_instruction"],
@@ -114,8 +156,11 @@ export const registerCoreAnalysisCommands = (cli, logger) => {
                 path: z.string().describe("Local native executable or app path"),
                 address: z.string().describe("Exact native address"),
             }),
-            options: z.object({ provider: providerSelectionOption }),
-            run: ({ args, options }) => logCliCommand(logger, command, () => runDirectAnalysis(args.path, operation, { address: args.address }, directAnalysisOptions(logger, undefined, options.provider))),
+            options: z.object({
+                "target-format": formatSelectionOption,
+                provider: providerSelectionOption,
+            }),
+            run: ({ args, options }) => logCliCommand(logger, command, () => runDirectAnalysis(args.path, operation, { address: args.address }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
         });
     }
     registerFunctionCommand(cli, logger);
@@ -146,10 +191,11 @@ const registerNativeDispatchMetadataCommand = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load or update the local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
         alias: { maxRecords: "max-records" },
-        run: async ({ args, options }) => logCliCommand(logger, "inspect-native-dispatch-metadata", () => runDirectAnalysis(args.path, "inspect_native_dispatch_metadata", { max_records: options.maxRecords }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: async ({ args, options }) => logCliCommand(logger, "inspect-native-dispatch-metadata", () => runDirectAnalysis(args.path, "inspect_native_dispatch_metadata", { max_records: options.maxRecords }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
 };
 const registerNativeUiActionCommand = (cli, logger) => {
@@ -184,6 +230,7 @@ const registerNativeUiActionCommand = (cli, logger) => {
                 .max(5_000)
                 .default(500)
                 .describe("Maximum returned graph edges"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
         alias: {
@@ -196,7 +243,7 @@ const registerNativeUiActionCommand = (cli, logger) => {
             max_depth: options.maxDepth,
             max_nodes: options.maxNodes,
             max_edges: options.maxEdges,
-        }, directAnalysisOptions(logger, undefined, options.provider))),
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
     });
 };
 const registerCoreCommands = (cli, logger) => {
@@ -206,6 +253,7 @@ const registerCoreCommands = (cli, logger) => {
             .min(1)
             .optional()
             .describe("Load and update a local analysis snapshot"),
+        "target-format": formatSelectionOption,
         provider: providerSelectionOption,
     });
     cli.command(CLI_COMMANDS.analyze, {
@@ -222,7 +270,7 @@ const registerCoreCommands = (cli, logger) => {
             path: z.string().describe("App, program, or analysis database path"),
         }),
         options: overviewOptions,
-        run: ({ args, options }) => logCliCommand(logger, "inspect", () => runDirectAnalysis(args.path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "inspect", () => runDirectAnalysis(args.path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
     cli.command(CLI_COMMANDS.decompile, {
         description: "Read one part of an app as code",
@@ -236,19 +284,21 @@ const registerCoreCommands = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
-        run: ({ args, options }) => logCliCommand(logger, "decompile", () => runDirectAnalysis(args.path, "procedure_pseudo_code", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "decompile", () => runDirectAnalysis(args.path, "procedure_pseudo_code", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
 };
 const runRoutedOverview = async (path, options, logger) => {
     if (options.provider === undefined &&
         options.snapshot === undefined &&
+        options["target-format"] === undefined &&
         (await isJavaScriptApplicationPath(path)))
         return runCliJavaScriptApplicationAnalysis({
             input_path: resolve(path),
         });
-    return runDirectAnalysis(path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider));
+    return runDirectAnalysis(path, "binary_overview", {}, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]));
 };
 const isJavaScriptApplicationPath = async (path) => {
     const lower = path.toLowerCase();
@@ -259,7 +309,10 @@ const isJavaScriptApplicationPath = async (path) => {
     try {
         return (await stat(path)).isDirectory();
     }
-    catch {
+    catch (cause) {
+        // A missing or unreadable path is not a JavaScript application directory;
+        // the caller falls through to direct binary analysis instead.
+        void cause;
         return false;
     }
 };
@@ -276,9 +329,10 @@ const registerXrefsCommand = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
-        run: ({ args, options }) => logCliCommand(logger, "xrefs", () => runDirectAnalysis(args.path, "xrefs", { address: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "xrefs", () => runDirectAnalysis(args.path, "xrefs", { address: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
 };
 const registerTraceCommand = (cli, logger) => {
@@ -298,6 +352,7 @@ const registerTraceCommand = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
         alias: {
@@ -306,7 +361,7 @@ const registerTraceCommand = (cli, logger) => {
         run: ({ args, options }) => logCliCommand(logger, "trace", () => runDirectAnalysis(args.path, "trace_feature", {
             query: args.query,
             case_sensitive: options.caseSensitive,
-        }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
 };
 const registerFunctionCommand = (cli, logger) => {
@@ -322,9 +377,10 @@ const registerFunctionCommand = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
-        run: ({ args, options }) => logCliCommand(logger, "function", () => runDirectAnalysis(args.path, "analyze_function", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "function", () => runDirectAnalysis(args.path, "analyze_function", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
 };
 const registerNativeApiCommand = (cli, logger) => {
@@ -340,9 +396,10 @@ const registerNativeApiCommand = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
-        run: ({ args, options }) => logCliCommand(logger, "inspect-native-api", () => runDirectAnalysis(args.path, "inspect_native_api", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        run: ({ args, options }) => logCliCommand(logger, "inspect-native-api", () => runDirectAnalysis(args.path, "inspect_native_api", { procedure: args.address }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
 };
 const registerInstructionsCommand = (cli, logger) => {
@@ -358,11 +415,12 @@ const registerInstructionsCommand = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
         run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.instructions, () => runDirectAnalysis(args.path, "read_function_instructions", {
             procedure: args.address,
-        }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
     });
 };
 const registerSearchCommand = (cli, logger) => {
@@ -390,6 +448,7 @@ const registerSearchCommand = (cli, logger) => {
                 .min(1)
                 .optional()
                 .describe("Load and update a local analysis snapshot"),
+            "target-format": formatSelectionOption,
             provider: providerSelectionOption,
         }),
         alias: { caseSensitive: "case-sensitive" },
@@ -397,6 +456,40 @@ const registerSearchCommand = (cli, logger) => {
             pattern: args.pattern,
             mode: options.mode,
             case_sensitive: options.caseSensitive,
-        }, directAnalysisOptions(logger, options.snapshot, options.provider))),
+        }, directAnalysisOptions(logger, options.snapshot, options.provider, options["target-format"]))),
+    });
+};
+const registerAnnotationCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.annotateNativeFunction, {
+        description: "Edit function annotations and return refreshed analysis",
+        args: z.object({
+            path: z.string().describe("Local executable path"),
+            procedure: z
+                .string()
+                .describe("Exact function entry address or unique name"),
+        }),
+        options: z.object({
+            name: z.string().min(1).optional().describe("Analyst function name"),
+            comment: z
+                .string()
+                .optional()
+                .describe("Regular entry comment; empty text clears it"),
+            "inline-comment": z
+                .string()
+                .optional()
+                .describe("Inline entry comment; empty text clears it"),
+            "target-format": formatSelectionOption,
+            provider: providerSelectionOption,
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.annotateNativeFunction, () => runDirectAnalysis(args.path, "annotate_native_function", {
+            procedure: args.procedure,
+            ...(options.name === undefined ? {} : { name: options.name }),
+            ...(options.comment === undefined
+                ? {}
+                : { comment: options.comment }),
+            ...(options["inline-comment"] === undefined
+                ? {}
+                : { inline_comment: options["inline-comment"] }),
+        }, directAnalysisOptions(logger, undefined, options.provider, options["target-format"]))),
     });
 };

package/dist/{cliElectronCommands.js → cli/electronCommands.js}

@@ -1,17 +1,18 @@
 import { Cli, z } from "incur";
-import { inspectElectronPage, listElectronTargets, } from "./application/ElectronObservationService.js";
-import { captureElectronScenario } from "./application/ElectronActiveObservationService.js";
-import { reconcileJavaScriptRuntimeEvidence } from "./application/JavaScriptRuntimeReconciliationService.js";
-import { CdpElectronProvider } from "./browser/CdpElectronProvider.js";
-import { PlaywrightElectronActiveProvider } from "./browser/PlaywrightElectronActiveProvider.js";
-import { logCliCommand } from "./cliLogging.js";
-import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "./domain/electronObservation.js";
-import { electronActiveObservationInputSchema } from "./domain/electronActiveObservation.js";
-import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
-import { CLI_COMMANDS } from "./cliCommandNames.js";
-import { parseCliJsonInput } from "./cliJsonInput.js";
-import { electronPageInspectionOptions, javascriptApplicationOptions, } from "./cliObservationOptions.js";
-import { runCliJavaScriptApplicationAnalysis } from "./cli/javascriptApplicationAnalysis.js";
+import { inspectElectronPage, listElectronTargets, } from "../application/ElectronObservationService.js";
+import { captureElectronScenario } from "../application/ElectronActiveObservationService.js";
+import { reconcileJavaScriptRuntimeEvidence } from "../application/JavaScriptRuntimeReconciliationService.js";
+import { CdpElectronProvider } from "../browser/CdpElectronProvider.js";
+import { PlaywrightElectronActiveProvider } from "../browser/PlaywrightElectronActiveProvider.js";
+import { logCliCommand } from "../cliLogging.js";
+import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "../domain/electronObservation.js";
+import { electronActiveObservationInputSchema } from "../domain/electronActiveObservation.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { parseCliJsonInput } from "../cliJsonInput.js";
+import { electronPageInspectionOptions, javascriptApplicationOptions, } from "../cliObservationOptions.js";
+import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
 /** Register CLI equivalents of the Electron MCP tools. */
 export const registerElectronCommands = (cli, logger) => {
     registerElectronObservationCommands(cli, logger);

package/dist/cli/firmwareCommands.js

@@ -0,0 +1,75 @@
+import { z } from "incur";
+import { FirmwareAnalysisService } from "../application/FirmwareAnalysisService.js";
+import { FirmwareProvider } from "../firmware/FirmwareProvider.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** One-shot firmware CLI commands backed by the same workflows as MCP. */
+export const registerFirmwareCommands = (cli, logger, environment) => {
+    const service = new FirmwareAnalysisService(new FirmwareProvider(environment));
+    const execute = (name, operation, input) => withCommandCancellation((signal) => logCliCommand(logger, name, async () => {
+        const result = await service.execute(operation, input, { signal });
+        return result.ok ? result.value : projectAnalysisError(result.error);
+    }));
+    const path = z.string().describe("Local firmware path; never executed");
+    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),
+    });
+    cli.command(CLI_COMMANDS.extractFirmware, {
+        description: "Extract selected firmware bytes and return verified files and provenance",
+        args: z.object({
+            path,
+            outputDirectory: z
+                .string()
+                .describe("Absolute absent output directory; parent must exist"),
+        }),
+        options: z.object({
+            offset: z
+                .number()
+                .int()
+                .nonnegative()
+                .optional()
+                .describe("Selected byte offset; requires length"),
+            length: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe("Selected byte length; requires offset"),
+            maxDepth: z
+                .number()
+                .int()
+                .optional()
+                .describe("Extraction depth, 1–10; default 3"),
+            maxOutputBytes: z
+                .number()
+                .int()
+                .optional()
+                .describe("Staging byte budget; default 256 MiB, maximum 512 MiB"),
+            maxOutputFiles: z
+                .number()
+                .int()
+                .optional()
+                .describe("Staging entry budget; default 10000"),
+        }),
+        run: ({ args, options }) => execute(CLI_COMMANDS.extractFirmware, "extract_firmware", {
+            path: args.path,
+            output_directory: args.outputDirectory,
+            ...(options.offset === undefined && options.length === undefined
+                ? {}
+                : { range: { offset: options.offset, length: options.length } }),
+            ...(options.maxDepth === undefined
+                ? {}
+                : { max_depth: options.maxDepth }),
+            ...(options.maxOutputBytes === undefined
+                ? {}
+                : { max_output_bytes: options.maxOutputBytes }),
+            ...(options.maxOutputFiles === undefined
+                ? {}
+                : { max_output_files: options.maxOutputFiles }),
+        }),
+    });
+};

package/dist/{cliSetup.js → cli/interactiveSetup.js}

@@ -1,5 +1,5 @@
 import { cancel, confirm, intro, isCancel, multiselect, outro, } from "@clack/prompts";
-import { SUPPORTED_CLIENT_DEFINITIONS } from "./application/SupportedClients.js";
+import { SUPPORTED_CLIENT_DEFINITIONS } from "../application/SupportedClients.js";
 const clientDisplayNames = new Map(SUPPORTED_CLIENT_DEFINITIONS.map(({ name, displayName }) => [
     name,
     displayName,

package/dist/cli/javascriptApplicationAnalysis.js

@@ -1,5 +1,5 @@
 import { analyzeJavaScriptApplication } from "../application/JavaScriptApplicationService.js";
-import { projectAnalysisError } from "../domain/errors.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);

package/dist/cli/managedCommands.js

@@ -4,7 +4,7 @@ import { verifyManagedNativeBoundariesEvidence } from "../application/ManagedNat
 import { importManagedReconstructionEvidence } from "../application/ManagedReconstructionService.js";
 import { runProviderAnalysis } from "../application/DirectAnalysis.js";
 import { parseCliJsonInput } from "../cliJsonInput.js";
-import { projectAnalysisError } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { registerProjectManagedApplicationGraph } from "./managedProjectGraphCommand.js";

package/dist/cli/managedProjectGraphCommand.js

@@ -3,7 +3,7 @@ import { projectManagedApplicationGraphEvidence } from "../application/ManagedAp
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { parseCliJsonInput } from "../cliJsonInput.js";
 import { logCliCommand } from "../cliLogging.js";
-import { projectAnalysisError } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 /** Register managed static-Evidence application graph projection. */
 export const registerProjectManagedApplicationGraph = (cli, logger) => {
     cli.command(CLI_COMMANDS.projectManagedApplicationGraph, {

package/dist/cli/options.js

@@ -1,9 +1,15 @@
+import { executableFormatHintSchema, } from "../domain/dosCom.js";
 import { analysisProviderSelectorSchema } from "../contracts/providerSelection.js";
 export const providerSelectionOption = analysisProviderSelectorSchema
     .optional()
     .describe("Bind deep analysis to a provider ID or use deterministic auto selection");
-export const directAnalysisOptions = (logger, snapshotPath, providerId) => ({
+/** Explicit interpretation for headerless native executable formats. */
+export const formatSelectionOption = executableFormatHintSchema
+    .optional()
+    .describe("Explicit headerless DOS COM interpretation");
+export const directAnalysisOptions = (logger, snapshotPath, providerId, formatHint) => ({
     logger,
     snapshotPath,
+    ...(formatHint === undefined ? {} : { formatHint }),
     ...(providerId === undefined ? {} : { providerId }),
 });

package/dist/{cliProcessCommands.js → cli/processCommands.js}

@@ -1,7 +1,7 @@
 import { Cli, z } from "incur";
-import { captureProcessScenarioFile, compareProcessEvidenceFiles, isProcessCliFailure, } from "./application/ProcessCli.js";
-import { logCliCommand } from "./cliLogging.js";
-import { CLI_COMMANDS } from "./cliCommandNames.js";
+import { captureProcessScenarioFile, compareProcessEvidenceFiles, isProcessCliFailure, } from "../application/ProcessCli.js";
+import { logCliCommand } from "../cliLogging.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
 /** Register direct process capture and comparison commands. */
 export const registerProcessCommands = (cli, logger, environment = process.env) => {
     cli.command(CLI_COMMANDS.captureProcess, {

package/dist/cli/referenceSourceImportStatus.js

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { isCliOperationFailure } from "../cliLogging.js";
+const referenceSourceImportFailureSchema = z.strictObject({
+    error: z.literal("Import failed"),
+    category: z.enum(["cancelled", "invalid_input", "execution_failure"]),
+    message: z.string().min(1),
+});
+/** Identify the historical-source import command's failed operation outputs. */
+export const isReferenceSourceImportCliFailure = (value) => referenceSourceImportFailureSchema.safeParse(value).success ||
+    isCliOperationFailure(value);

package/dist/cli/setupCommands.js

@@ -1,10 +1,12 @@
 import { z } from "incur";
 import { DOCTOR_PROVIDER_IDS, runDoctor, } from "../application/Doctor.js";
-import { runSetup, isSetupFailure, systemSetupHost, } from "../application/Setup.js";
+import { isSetupFailure, } from "../application/SetupTypes.js";
+import { runSetup } from "../application/Setup.js";
+import { systemSetupHost } from "../application/SetupHost.js";
 import { isUninstallFailure, runUninstall } from "../application/Uninstall.js";
 import { isUpdateFailure, runUpdate } from "../application/Update.js";
 import { systemUpdateHost } from "../application/UpdateRuntime.js";
-import { confirmInteractiveSetup, renderInteractiveSetupResult, renderSetupProgress, } from "../cliSetup.js";
+import { confirmInteractiveSetup, renderInteractiveSetupResult, renderSetupProgress, } from "./interactiveSetup.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { logCliCommand } from "../cliLogging.js";
 import { createSystemDoctorHost } from "../doctorRuntime.js";

package/dist/cli/utilityCommands.js

@@ -4,10 +4,11 @@ import { runCapabilityStatus, runProviderAnalysis, runProviderStatus, } from "..
 import { importReferenceSource } from "../application/ReferenceSourceImport.js";
 import { projectReferenceSourceImportError } from "../application/ReferenceSourceImportTypes.js";
 import { parseConfig } from "../config.js";
-import { projectAnalysisError } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { logCliCommand } from "../cliLogging.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { isReferenceSourceImportCliFailure } from "./referenceSourceImportStatus.js";
 export const registerUtilityCommands = (cli, logger, environment = process.env) => {
     registerCapabilityCommands(cli, logger);
     registerNativeCommands(cli, logger);
@@ -148,6 +149,6 @@ const registerReferenceSourceCommand = (cli, logger, environment = process.env)
                     error: "Import failed",
                     ...projectReferenceSourceImportError(imported.error),
                 };
-        }),
+        }, isReferenceSourceImportCliFailure),
     });
 };

package/dist/cli.js

@@ -1,5 +1,4 @@
 import { Cli } from "incur";
-import { fileURLToPath } from "node:url";
 import { createLogger, parseLogLevel } from "./logger.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
 import { registerSetupCommands } from "./cli/setupCommands.js";
@@ -7,14 +6,16 @@ import { registerCoreAnalysisCommands } from "./cli/coreAnalysisCommands.js";
 import { registerUtilityCommands } from "./cli/utilityCommands.js";
 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 { registerEvidenceCommands } from "./cliEvidenceCommands.js";
-import { registerProcessCommands } from "./cliProcessCommands.js";
-import { registerBrowserCommands } from "./cliBrowserCommands.js";
-import { registerAdvancedBrowserCommands } from "./cliBrowserAdvancedCommands.js";
+import { registerProcessCommands } from "./cli/processCommands.js";
+import { registerBrowserCommands } from "./cli/browserCommands.js";
+import { registerAdvancedBrowserCommands } from "./cli/browserAdvancedCommands.js";
 import { registerBrowserScenarioCommands } from "./cliBrowserScenarioCommands.js";
-import { registerElectronCommands } from "./cliElectronCommands.js";
+import { registerElectronCommands } from "./cli/electronCommands.js";
 import { registerJavaScriptRuntimeObservationCommands } from "./cliJavaScriptRuntimeCommands.js";
-import { registerApplicationCommands } from "./cliApplicationCommands.js";
+import { registerApplicationCommands } from "./cli/applicationCommands.js";
 /**
  * Build the one-shot Incur CLI without starting Hopper at import time.
  * Analysis commands acquire and close their own sessions; bare `mcp` and
@@ -31,21 +32,15 @@ export const createCli = (environment = process.env) => {
             command: PRODUCT_IDENTITY.mcpCommand,
             instructions: "Ask what software, artifact, protocol, or behavior the user wants to understand, then choose the available investigation capabilities that can produce evidence.",
         },
-        sync: {
-            cwd: fileURLToPath(new URL("..", import.meta.url)),
-            include: ["skills/*"],
-            suggestions: [
-                "understand how a software feature works",
-                "investigate an artifact or observed behavior",
-                "check my REA setup",
-            ],
-        },
+        sync: false,
     });
     registerSetupCommands(cli, logger);
     registerCoreAnalysisCommands(cli, logger);
     registerUtilityCommands(cli, logger, environment);
     registerArtifactCommands(cli, logger);
     registerManagedCommands(cli, logger);
+    registerAndroidCommands(cli, logger, environment);
+    registerFirmwareCommands(cli, logger, environment);
     registerEvidenceCommands(cli, logger);
     registerProcessCommands(cli, logger, environment);
     registerBrowserCommands(cli, logger);

package/dist/cliBrowserContext.js

@@ -1,5 +1,5 @@
 import { CdpBrowserProvider } from "./browser/CdpBrowserProvider.js";
-import { projectAnalysisError } from "./domain/errors.js";
+import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 /** Build the passive browser provider; scope is supplied on each request. */
 export const browserContext = () => ({ provider: new CdpBrowserProvider() });
 /** Project a browser operation failure consistently across CLI command groups. */

package/dist/cliBrowserScenarioCommands.js

@@ -5,7 +5,8 @@ import { PlaywrightBrowserScenarioProvider } from "./browser/PlaywrightBrowserSc
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { parseCliJsonInput } from "./cliJsonInput.js";
 import { logCliCommand } from "./cliLogging.js";
-import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
+import { AnalysisInputError } from "./domain/analysisErrorCore.js";
+import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { browserScenarioSchema } from "./domain/browserScenario.js";
 const OPERATION = "capture_browser_scenario";
 /** Register the one-shot controlled browser scenario command. */

package/dist/cliCommandNames.js

@@ -14,6 +14,7 @@ export const CLI_COMMANDS = Object.freeze({
     capabilities: "capabilities",
     providers: "providers",
     function: "function",
+    annotateNativeFunction: "annotate-native-function",
     inspectNativeApi: "inspect-native-api",
     instructions: "instructions",
     search: "search",
@@ -23,11 +24,21 @@ export const CLI_COMMANDS = Object.freeze({
     decodeInterfaceBuilder: "decode-interface-builder",
     inspectKeyedArchive: "inspect-keyed-archive",
     inspectNativeDataType: "inspect-native-data-type",
+    inspectNativeLoadImage: "inspect-native-load-image",
+    readBytes: "read-bytes",
+    addressToFileOffset: "address-to-file-offset",
     traceNativeValues: "trace-native-values",
     inspectNativeInstruction: "inspect-native-instruction",
     resolveNativeCallTargets: "resolve-native-call-targets",
     inspectAssetCatalog: "inspect-asset-catalog",
     inspectManagedArtifact: "inspect-managed-artifact",
+    inspectFirmwareRegions: "inspect-firmware-regions",
+    extractFirmware: "extract-firmware",
+    inspectAndroidPackage: "inspect-android-package",
+    searchAndroidClasses: "search-android-classes",
+    inspectAndroidClass: "inspect-android-class",
+    inspectAndroidMethod: "inspect-android-method",
+    traceAndroidReferences: "trace-android-references",
     inspectManagedMembers: "inspect-managed-members",
     inspectManagedNativeBoundaries: "inspect-managed-native-boundaries",
     compareManagedMembers: "compare-managed-members",
@@ -108,8 +119,6 @@ export const MCP_TOOLS_WITHOUT_DEDICATED_CLI = Object.freeze([
     "procedure_callees",
     "procedure_callers",
     "procedure_info",
-    "read_bytes",
-    "address_to_file_offset",
     "procedure_references",
     "resolve_containing_procedure",
     "set_address_name",