rea-agents 4.1.0 → 5.0.0

package/dist/cli/utilityCommands.js

@@ -1,13 +1,17 @@
 import { z } from "incur";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { runCapabilityStatus, runProviderAnalysis, runProviderStatus, } from "../application/DirectAnalysis.js";
+import { runCapabilityStatus, runProviderAnalysis, runProviderStatus, } from "../composition/directAnalysis.js";
 import { importReferenceSource } from "../application/ReferenceSourceImport.js";
 import { projectReferenceSourceImportError } from "../application/ReferenceSourceImportTypes.js";
 import { parseConfig } from "../config.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { projectInputIssues } from "../domain/inputIssueProjection.js";
+import { safeParseJson } from "../domain/safeJson.js";
+import { nativeUiScenarioInputSchema } from "../domain/native/nativeUiObservation.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { logCliCommand } from "../cliLogging.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { swiftSymbolsSchema } from "../contracts/native/nativeToolContracts.js";
 import { isReferenceSourceImportCliFailure } from "./referenceSourceImportStatus.js";
 export const registerUtilityCommands = (cli, logger, environment = process.env) => {
     registerCapabilityCommands(cli, logger);
@@ -52,24 +56,45 @@ export const registerUtilityCommands = (cli, logger, environment = process.env)
                 windowId: "window-id",
                 maxNodes: "max-nodes",
             },
-            run: ({ args, options }) => logCliCommand(logger, command, () => runProviderAnalysis(args.path, operation, {
-                pid: options.pid,
-                window_id: options.windowId,
-                screenshot: options.screenshot,
-                accessibility: options.accessibility,
-                max_nodes: options.maxNodes,
-                ...(operation === "capture_native_ui_scenario"
-                    ? {
-                        steps: options.steps === undefined
-                            ? []
-                            : jsonValueSchema.parse(JSON.parse(options.steps)),
-                    }
-                    : {}),
-            }, logger)),
+            run: ({ args, options }) => logCliCommand(logger, command, async () => {
+                const parameters = {
+                    pid: options.pid,
+                    window_id: options.windowId,
+                    screenshot: options.screenshot,
+                    accessibility: options.accessibility,
+                    max_nodes: options.maxNodes,
+                };
+                if (operation === "capture_native_ui_scenario") {
+                    const decoded = options.steps === undefined
+                        ? { ok: true, value: undefined }
+                        : safeParseJson(options.steps);
+                    if (!decoded.ok)
+                        return invalidNativeUiScenarioInput(operation, [
+                            { path: ["steps"], reason: "invalid_format", expected: "JSON" },
+                        ]);
+                    const parsed = nativeUiScenarioInputSchema.safeParse({
+                        ...parameters,
+                        steps: decoded.value,
+                    });
+                    if (!parsed.success)
+                        return invalidNativeUiScenarioInput(operation, projectInputIssues(parsed.error.issues, {
+                            ...parameters,
+                            ...(options.steps === undefined
+                                ? {}
+                                : { steps: decoded.value }),
+                        }));
+                    return runProviderAnalysis(args.path, operation, parsed.data, logger);
+                }
+                return runProviderAnalysis(args.path, operation, parameters, logger);
+            }),
         });
     }
     registerReferenceSourceCommand(cli, logger, environment);
 };
+const invalidNativeUiScenarioInput = (operation, issues) => ({
+    error: "Application workflow failed",
+    ...projectAnalysisError(new AnalysisInputError(operation, undefined, issues)),
+});
 const registerCapabilityCommands = (cli, logger) => {
     for (const command of [
         CLI_COMMANDS.capabilities,
@@ -103,20 +128,19 @@ const registerNativeCommands = (cli, logger) => {
         options: z.object({
             relativePath: z
                 .string()
-                .default("Contents/Info.plist")
-                .describe("Plist path relative to the app root"),
+                .optional()
+                .describe("Plist path relative to the app root (default: Contents/Info.plist)"),
         }),
         alias: { relativePath: "relative-path" },
-        run: ({ args, options }) => logCliCommand(logger, "inspect-plist", () => runProviderAnalysis(args.path, "inspect_plist", { relative_path: options.relativePath }, logger)),
+        run: ({ args, options }) => logCliCommand(logger, "inspect-plist", () => runProviderAnalysis(args.path, "inspect_plist", options.relativePath === undefined
+            ? {}
+            : { path: options.relativePath }, logger)),
     });
     cli.command(CLI_COMMANDS.demangleSwift, {
         description: "Demangle Swift symbols without Hopper",
         args: z.object({
             path: z.string().describe("Artifact path used for evidence identity"),
-            symbols: z
-                .array(z.string().min(1))
-                .min(1)
-                .describe("Swift mangled symbols to demangle"),
+            symbols: swiftSymbolsSchema.describe("Swift mangled symbols to demangle"),
         }),
         run: ({ args }) => logCliCommand(logger, "demangle-swift", () => runProviderAnalysis(args.path, "demangle_swift", { symbols: args.symbols }, logger)),
     });

package/dist/cli/webModuleCommands.js

@@ -0,0 +1,56 @@
+import { z } from "incur";
+import { createWebModuleTraceService } from "../composition/webModules.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Expose the same selected-context module trace through the CLI. */
+export const registerWebModuleCommands = (cli, logger, environment) => {
+    const service = createWebModuleTraceService(environment);
+    cli.command(CLI_COMMANDS.traceWebModuleImports, {
+        description: "Trace one captured script's native imports to URLs and captured source candidates",
+        args: z.object({
+            manifestPath: z
+                .string()
+                .describe("Absolute export_web_scripts manifest path"),
+            scriptIndex: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based manifest script index"),
+        }),
+        options: z.object({
+            importerUrl: z
+                .string()
+                .optional()
+                .describe("Explicit HTTP(S) importer URL"),
+            importMapPath: z
+                .string()
+                .optional()
+                .describe("Absolute local import-map JSON"),
+            importMapBaseUrl: z
+                .string()
+                .optional()
+                .describe("HTTP(S) import-map base URL"),
+        }),
+        run: ({ args, options }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.traceWebModuleImports, async () => {
+            const result = await service.trace({
+                manifest_path: args.manifestPath,
+                script_index: args.scriptIndex,
+                ...(options.importerUrl === undefined
+                    ? {}
+                    : { importer_url: options.importerUrl }),
+                ...(options.importMapPath === undefined &&
+                    options.importMapBaseUrl === undefined
+                    ? {}
+                    : {
+                        import_map: {
+                            path: options.importMapPath,
+                            base_url: options.importMapBaseUrl,
+                        },
+                    }),
+            }, { signal });
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
+    });
+};

package/dist/cli/webRuntimeCommands.js

@@ -0,0 +1,60 @@
+import { Cli, z } from "incur";
+import { createWebRuntimeService } from "../composition/webRuntime.js";
+import { browserCliError } from "../cliBrowserContext.js";
+import { browserScopeOptions, observationDuration, } from "../cliObservationOptions.js";
+import { logCliCommand } from "../cliLogging.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** CLI progress exposes the actual armed point on stderr without corrupting JSON results. */
+const runtimeProgress = {
+    report: async (update) => {
+        process.stderr.write(`${JSON.stringify({ rea_progress: update })}\n`);
+    },
+};
+/** Register public equivalents of the two modular website runtime tools. */
+export const registerWebRuntimeCommands = (cli, logger) => {
+    cli.command(CLI_COMMANDS.observeWebExecution, {
+        description: "Observe precise page execution; resets counters and temporarily disables optimization",
+        args: z.object({
+            endpoint: z.string().describe("Existing loopback browser CDP endpoint"),
+            targetId: z
+                .string()
+                .describe("Selected page target ID from list-browser-targets"),
+        }),
+        options: z.object({
+            ...browserScopeOptions,
+            observationMs: observationDuration(10_000, 1),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, "observe-web-execution", async () => {
+            const result = await withCommandCancellation((signal) => createWebRuntimeService().observe({
+                cdp_endpoint: args.endpoint,
+                target_id: args.targetId,
+                allowed_origins: options.allowedOrigins,
+                observation_ms: options.observationMs,
+            }, { 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",
+        args: z.object({
+            endpoint: z.string().describe("Existing loopback browser CDP endpoint"),
+            targetId: z
+                .string()
+                .describe("Selected page target ID from list-browser-targets"),
+            selector: z
+                .string()
+                .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({
+                cdp_endpoint: args.endpoint,
+                target_id: args.targetId,
+                selector: args.selector,
+                allowed_origins: options.allowedOrigins,
+            }, { signal }));
+            return result.ok ? result.value : browserCliError(result.error);
+        }),
+    });
+};

package/dist/cli/webScriptCommands.js

@@ -0,0 +1,31 @@
+import { Cli, z } from "incur";
+import { exportWebScripts } from "../application/WebScriptExportService.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+/** Register the local captured-script export CLI workflow. */
+export const registerWebScriptCommands = (cli, logger) => {
+    cli.command(CLI_COMMANDS.exportWebScripts, {
+        description: "Export retained website scripts into an absent directory for static JavaScript analysis",
+        args: z.object({
+            capturePath: z
+                .string()
+                .describe("Absolute path to saved page or scenario capture JSON"),
+            outputDirectory: z
+                .string()
+                .describe("Absolute absent directory for verified scripts and manifest"),
+        }),
+        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.exportWebScripts, async () => {
+            const result = await exportWebScripts({
+                capture_path: args.capturePath,
+                output_directory: args.outputDirectory,
+            });
+            return result.ok
+                ? result.value
+                : {
+                    error: "Script export failed",
+                    ...projectAnalysisError(result.error),
+                };
+        }),
+    });
+};

package/dist/cli/webSourceLocationCommands.js

@@ -0,0 +1,42 @@
+import { z } from "incur";
+import { createWebSourceLocationService } from "../composition/webSourceLocations.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { logCliCommand } from "../cliLogging.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { withCommandCancellation } from "./commandCancellation.js";
+/** Expose the same explicit selected map/point contract through the CLI. */
+export const registerWebSourceLocationCommands = (cli, logger, environment) => {
+    const service = createWebSourceLocationService(environment);
+    cli.command(CLI_COMMANDS.traceWebSourceLocation, {
+        description: "Trace one retained script position through an explicitly selected local source map",
+        args: z.object({
+            manifestPath: z
+                .string()
+                .describe("Absolute export_web_scripts manifest path"),
+            scriptIndex: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based manifest script index"),
+            sourceMapPath: z.string().describe("Absolute local source-map path"),
+            sourceMapUrl: z
+                .string()
+                .describe("Absolute source-map URL context; no fetch"),
+            line: z.coerce.number().int().min(1).describe("One-based generated line"),
+            column: z.coerce
+                .number()
+                .int()
+                .min(0)
+                .describe("Zero-based UTF-16 generated column"),
+        }),
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.traceWebSourceLocation, async () => {
+            const result = await service.trace({
+                manifest_path: args.manifestPath,
+                script_index: args.scriptIndex,
+                source_map: { path: args.sourceMapPath, url: args.sourceMapUrl },
+                generated_position: { line: args.line, column: args.column },
+            }, { signal });
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        })),
+    });
+};

package/dist/cli.js

@@ -11,6 +11,11 @@ import { registerAndroidCommands } from "./cli/androidCommands.js";
 import { registerEvidenceCommands } from "./cliEvidenceCommands.js";
 import { registerProcessCommands } from "./cli/processCommands.js";
 import { registerBrowserCommands } from "./cli/browserCommands.js";
+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 { registerJavaScriptRecoveryCommands } from "./cli/javascriptRecoveryCommands.js";
 import { registerAdvancedBrowserCommands } from "./cli/browserAdvancedCommands.js";
 import { registerBrowserScenarioCommands } from "./cliBrowserScenarioCommands.js";
 import { registerElectronCommands } from "./cli/electronCommands.js";
@@ -44,6 +49,11 @@ export const createCli = (environment = process.env) => {
     registerEvidenceCommands(cli, logger);
     registerProcessCommands(cli, logger, environment);
     registerBrowserCommands(cli, logger);
+    registerWebScriptCommands(cli, logger);
+    registerWebModuleCommands(cli, logger, environment);
+    registerWebSourceLocationCommands(cli, logger, environment);
+    registerWebRuntimeCommands(cli, logger);
+    registerJavaScriptRecoveryCommands(cli, logger, environment);
     registerAdvancedBrowserCommands(cli, logger);
     registerBrowserScenarioCommands(cli, logger);
     registerElectronCommands(cli, logger);

package/dist/cliBrowserContext.js

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

package/dist/cliBrowserScenarioCommands.js

@@ -1,12 +1,13 @@
 import { Cli } from "incur";
 import { z } from "zod";
 import { captureBrowserScenario } from "./application/BrowserScenarioCaptureService.js";
-import { PlaywrightBrowserScenarioProvider } from "./browser/PlaywrightBrowserScenarioProvider.js";
+import { createBrowserScenarioProvider } from "./composition/browserScenario.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { parseCliJsonInput } from "./cliJsonInput.js";
 import { logCliCommand } from "./cliLogging.js";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
+import { projectInputIssues } from "./domain/inputIssueProjection.js";
 import { browserScenarioSchema } from "./domain/browserScenario.js";
 const OPERATION = "capture_browser_scenario";
 /** Register the one-shot controlled browser scenario command. */
@@ -24,8 +25,8 @@ export const registerBrowserScenarioCommands = (cli, logger) => {
                 return input.error;
             const scenario = browserScenarioSchema.safeParse(input.value);
             if (!scenario.success)
-                return cliError(new AnalysisInputError(OPERATION));
-            const result = await captureBrowserScenario(new PlaywrightBrowserScenarioProvider(), scenario.data);
+                return cliError(new AnalysisInputError(OPERATION, { cause: scenario.error }, projectInputIssues(scenario.error.issues, input.value)));
+            const result = await captureBrowserScenario(createBrowserScenarioProvider(), scenario.data);
             return result.ok ? result.value : cliError(result.error);
         }),
     });

package/dist/cliCommandNames.js

@@ -1,5 +1,9 @@
 /** Canonical names used by every one-shot CLI command registration. */
 export const CLI_COMMANDS = Object.freeze({
+    observeWebExecution: "observe-web-execution",
+    inspectWebEventListeners: "inspect-web-event-listeners",
+    traceWebSourceLocation: "trace-web-source-location",
+    traceWebModuleImports: "trace-web-module-imports",
     analyze: "analyze",
     inspect: "inspect",
     decompile: "decompile",
@@ -60,6 +64,8 @@ export const CLI_COMMANDS = Object.freeze({
     listBrowserTargets: "list-browser-targets",
     inspectWebPage: "inspect-web-page",
     analyzeWebBundle: "analyze-web-bundle",
+    exportWebScripts: "export-web-scripts",
+    recoverJavaScriptSources: "recover-javascript-sources",
     observeWebSession: "observe-web-session",
     discoverWebMcpTools: "discover-webmcp-tools",
     compareWebCaptures: "compare-web-captures",
@@ -80,6 +86,8 @@ export const CLI_COMMANDS = Object.freeze({
     compareJavaScriptExportShapes: "compare-javascript-export-shapes",
     buildReconstructionObligationLedger: "build-reconstruction-obligation-ledger",
     evaluateReconstructionCoverage: "evaluate-reconstruction-coverage",
+    projectAndroidApplicationGraph: "project-android-application-graph",
+    projectAppleApplicationGraph: "project-apple-application-graph",
 });
 /** Ordered primary CLI inventory; aliases are intentionally excluded. */
 export const CLI_COMMAND_NAMES = Object.freeze(Object.values(CLI_COMMANDS));

package/dist/cliJavaScriptRuntimeCommands.js

@@ -1,9 +1,9 @@
 import { Cli, z } from "incur";
-import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "./application/JavaScriptRuntimeObservationService.js";
-import { V8InspectorProvider } from "./browser/V8InspectorProvider.js";
+import { listJavaScriptRuntimeTargets, observeJavaScriptRuntime, } from "./application/javascript/JavaScriptRuntimeObservationService.js";
+import { createJavaScriptRuntimeObservationProvider } from "./composition/javascriptRuntimeObservation.js";
 import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { logCliCommand } from "./cliLogging.js";
-import { javascriptRuntimeKindSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "./domain/javascriptRuntimeObservation.js";
+import { javascriptRuntimeKindSchema, listJavaScriptRuntimeTargetsInputSchema, observeJavaScriptRuntimeInputSchema, } from "./domain/javascript/javascriptRuntimeObservation.js";
 import { AnalysisInputError } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 const observeOptionsSchema = z.object({
@@ -59,7 +59,9 @@ export const registerJavaScriptRuntimeObservationCommands = (cli, logger) => {
         }),
     });
 };
-const runtimeContext = () => ({ provider: new V8InspectorProvider() });
+const runtimeContext = () => ({
+    provider: createJavaScriptRuntimeObservationProvider(),
+});
 const inputError = (operation) => cliError(new AnalysisInputError(operation));
 const cliError = (error) => ({
     error: "JavaScript runtime observation failed",

package/dist/cliJsonInput.js

@@ -7,8 +7,6 @@ export const parseCliJsonInput = async (value, operation) => {
     const inline = parseJson(value);
     if (inline !== undefined)
         return { ok: true, value: inline };
-    if (["{", "["].includes(value.trimStart()[0] ?? ""))
-        return { ok: false, error: inputError(operation) };
     try {
         // Read raw bytes so invalid UTF-8 is rejected by parseJson instead of
         // being silently replaced by lossy "utf8" decoding.
@@ -18,9 +16,18 @@ export const parseCliJsonInput = async (value, operation) => {
             : { ok: true, value: parsed };
     }
     catch (cause) {
+        if (["{", "["].includes(value.trimStart()[0] ?? "") &&
+            cannotBeAnExistingFile(cause) &&
+            !hasExplicitJsonFileExtension(value))
+            return { ok: false, error: inputError(operation) };
         return jsonFileError(value, operation, "read-failed", cause);
     }
 };
+const cannotBeAnExistingFile = (cause) => typeof cause === "object" &&
+    cause !== null &&
+    "code" in cause &&
+    (cause.code === "ENOENT" || cause.code === "ENAMETOOLONG");
+const hasExplicitJsonFileExtension = (value) => value.toLowerCase().endsWith(".json");
 const parseJson = (value) => {
     let text;
     if (typeof value === "string") {

package/dist/cliOutput.js

@@ -1,6 +1,7 @@
 import { safeParseJson } from "./domain/safeJson.js";
 const SAFE_VALIDATION_MESSAGE = "REA could not read the command arguments. Run `rea --help`, correct the arguments, then try again.";
 const UNSUPPORTED_OUTPUT_COMBINATION_MESSAGE = "Token windows cannot preserve structured output. Remove --token-limit/--token-offset and use --filter-output or command pagination.";
+const INCUR_OUTPUT_FORMATS = new Set(["toon", "json", "yaml", "md", "jsonl"]);
 const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const validationError = (value) => {
     if (value.code === "VALIDATION_ERROR")
@@ -9,41 +10,56 @@ const validationError = (value) => {
         return value.error.code === "VALIDATION_ERROR" ? value.error : undefined;
     return undefined;
 };
-/** Reject text-window controls that would corrupt a structured document. */
-export const validateCliOutputArguments = (arguments_) => {
+const parseCliOutputArguments = (arguments_) => {
     let format = "toon";
+    let filterOutput = false;
     let tokenWindow = false;
     for (let index = 0; index < arguments_.length; index += 1) {
         const argument = arguments_[index];
-        if (argument === "--")
-            break;
+        // Incur scans builtins across `--` and accepts only spaced value forms.
+        // Mirror those effective values at the executable output boundary.
         if (argument === "--json") {
             format = "json";
             continue;
         }
         if (argument === "--format") {
             const value = arguments_[index + 1];
-            if (value !== undefined) {
+            if (value) {
+                // 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 };
                 format = value;
                 index += 1;
             }
             continue;
         }
-        if (argument?.startsWith("--format=")) {
-            format = argument.slice("--format=".length);
+        if (argument === "--filter-output") {
+            if (arguments_[index + 1]) {
+                filterOutput = true;
+                index += 1;
+            }
             continue;
         }
         if (argument === "--token-limit" || argument === "--token-offset") {
-            if (arguments_[index + 1] !== undefined) {
+            const value = arguments_[index + 1];
+            if (value) {
+                const numericValue = Number(value);
+                if (!Number.isFinite(numericValue) || value.trim() === "")
+                    return { filterOutput, format, parseError: true, tokenWindow: false };
                 tokenWindow = true;
                 index += 1;
             }
             continue;
         }
-        if (argument?.startsWith("--token-limit=") ||
-            argument?.startsWith("--token-offset="))
-            tokenWindow = true;
     }
+    return { filterOutput, format, parseError: false, tokenWindow };
+};
+/** Reject text-window controls that would corrupt a structured document. */
+export const validateCliOutputArguments = (arguments_) => {
+    const { format, parseError, tokenWindow } = parseCliOutputArguments(arguments_);
+    if (parseError)
+        return { ok: true };
     if (tokenWindow &&
         (format === "json" || format === "jsonl" || format === "yaml"))
         return {
@@ -54,6 +70,16 @@ export const validateCliOutputArguments = (arguments_) => {
         };
     return { ok: true };
 };
+/** Preserve a complete document when Incur filters the entire result away. */
+export const renderEmptyFilteredCliOutput = (arguments_) => {
+    const { filterOutput, format, parseError } = parseCliOutputArguments(arguments_);
+    if (parseError)
+        return undefined;
+    if (filterOutput &&
+        (format === "json" || format === "jsonl" || format === "yaml"))
+        return "{}\n";
+    return undefined;
+};
 /** Render one complete structured error before command execution. */
 export const renderCliOutputArgumentError = (error) => {
     const value = {

package/dist/composition/android.js

@@ -0,0 +1,3 @@
+import { JadxProvider } from "../android/JadxProvider.js";
+/** Construct one APK provider with its own queue and cleanup-failure state. */
+export const createAndroidAnalysisProvider = (environment = process.env, launcher) => new JadxProvider(environment, launcher);

package/dist/composition/auxiliaryAnalysisProviders.js

@@ -0,0 +1,30 @@
+import { ARTIFACT_PROVIDER_IDENTITY, artifactCapabilities, } from "../artifacts/ArtifactProviderMetadata.js";
+import { MANAGED_STATIC_PROVIDER_IDENTITY, managedStaticCapabilities, } from "../dotnet/ManagedStaticProviderMetadata.js";
+import { NATIVE_MACOS_PROVIDER_IDENTITY, nativeMacOSCapabilities, } from "../native/NativeMacOSProviderMetadata.js";
+/** Wire the three existing auxiliary AnalysisProvider implementations lazily. */
+export const auxiliaryAnalysisProviderDeclarations = (platform = process.platform) => [
+    {
+        identity: ARTIFACT_PROVIDER_IDENTITY,
+        capabilities: artifactCapabilities(platform),
+        load: async () => {
+            const { ArtifactProvider } = await import("../artifacts/ArtifactProvider.js");
+            return new ArtifactProvider(platform);
+        },
+    },
+    {
+        identity: NATIVE_MACOS_PROVIDER_IDENTITY,
+        capabilities: nativeMacOSCapabilities(platform),
+        load: async () => {
+            const { NativeMacOSProvider } = await import("../native/NativeMacOSProvider.js");
+            return new NativeMacOSProvider(undefined, platform);
+        },
+    },
+    {
+        identity: MANAGED_STATIC_PROVIDER_IDENTITY,
+        capabilities: managedStaticCapabilities(),
+        load: async () => {
+            const { ManagedStaticProvider } = await import("../dotnet/ManagedStaticProvider.js");
+            return new ManagedStaticProvider();
+        },
+    },
+];

package/dist/composition/binary.js

@@ -0,0 +1,25 @@
+import { HopperProvider } from "../hopper/HopperProvider.js";
+import { GhidraProvider } from "../ghidra/GhidraProvider.js";
+import { IdaProvider } from "../ida/IdaProvider.js";
+import { silentLogger } from "../logger.js";
+import { auxiliaryAnalysisProviderDeclarations } from "./auxiliaryAnalysisProviders.js";
+import { AnalysisProviderRegistry } from "../application/binary/AnalysisProviderRegistry.js";
+import { composeBinarySession } from "../application/binary/BinarySessionComposition.js";
+import { LazyAnalysisProvider } from "../application/binary/LazyAnalysisProvider.js";
+import { ManagedStaticProvider } from "../dotnet/ManagedStaticProvider.js";
+import { SessionProviderRouter } from "../application/binary/SessionProviderRouter.js";
+/**
+ * Compose the target-switching runtime shared directly by CLI and MCP adapters.
+ * This is the sole production wiring point, so both adapters share identical
+ * provider selection, profile, lifecycle, and Evidence semantics.
+ */
+export const createBinarySession = (config, logger = silentLogger) => {
+    const hopper = new HopperProvider(config, logger);
+    const ghidra = new GhidraProvider(config, logger);
+    const ida = new IdaProvider(config);
+    return composeBinarySession(new AnalysisProviderRegistry([hopper, ghidra, ida], config.analysisProvider), auxiliaryAnalysisProviderDeclarations().map((declaration) => new LazyAnalysisProvider(declaration)));
+};
+/** Compose an execution-free managed session without native provider selection. */
+export const createManagedBinarySession = () => composeBinarySession(SessionProviderRouter.selectable(new AnalysisProviderRegistry([]), [
+    new ManagedStaticProvider(),
+]));

package/dist/composition/browserObservation.js

@@ -0,0 +1,3 @@
+import { CdpBrowserProvider } from "../browser/CdpBrowserProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createBrowserObservationProvider = () => new CdpBrowserProvider();

package/dist/composition/browserScenario.js

@@ -0,0 +1,3 @@
+import { PlaywrightBrowserScenarioProvider } from "../browser/PlaywrightBrowserScenarioProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createBrowserScenarioProvider = () => new PlaywrightBrowserScenarioProvider();

package/dist/composition/directAnalysis.js

@@ -0,0 +1,17 @@
+import { runDirectAnalysis as executeDirectAnalysis, runProviderAnalysis as executeProviderAnalysis, runManagedProviderExecution as executeManagedProvider, } from "../application/DirectAnalysis.js";
+import { runCapabilityStatus as executeCapabilityStatus, runProviderStatus as executeProviderStatus, } from "../application/DirectAnalysisStatus.js";
+import { createBinarySession, createManagedBinarySession } from "./binary.js";
+const dependencies = {
+    createBinarySession,
+    createManagedBinarySession,
+};
+/** Run one isolated binary operation through the production session factory. */
+export const runDirectAnalysis = executeDirectAnalysis.bind(undefined, dependencies);
+/** Run one isolated native, artifact or managed operation. */
+export const runProviderAnalysis = executeProviderAnalysis.bind(undefined, dependencies);
+/** Execute managed metadata without constructing native provider candidates. */
+export const runManagedProviderExecution = executeManagedProvider.bind(undefined, dependencies);
+/** Report production provider candidates without opening a target. */
+export const runProviderStatus = executeProviderStatus.bind(undefined, dependencies);
+/** Report production session operations without opening a target. */
+export const runCapabilityStatus = executeCapabilityStatus.bind(undefined, dependencies);

package/dist/composition/electronObservation.js

@@ -0,0 +1,3 @@
+import { CdpElectronProvider } from "../browser/CdpElectronProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createElectronObservationProvider = () => new CdpElectronProvider();

package/dist/composition/electronScenario.js

@@ -0,0 +1,3 @@
+import { PlaywrightElectronActiveProvider } from "../browser/PlaywrightElectronActiveProvider.js";
+/** Construct a fresh provider without opening a target or acquiring an engine. */
+export const createElectronScenarioProvider = () => new PlaywrightElectronActiveProvider();