rea-agents 6.0.0 → 6.2.0

package/dist/cli/electronCommands.js

@@ -12,22 +12,23 @@ import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { parseCliJsonInput, resolveCliJsonPaths } from "../cliJsonInput.js";
 import { electronPageInspectionOptions, javascriptApplicationOptions, } from "../cliObservationOptions.js";
 import { runCliJavaScriptApplicationAnalysis } from "./javascriptApplicationAnalysis.js";
+import { withCommandCancellation } from "./commandCancellation.js";
 /** Register CLI equivalents of the Electron MCP tools. */
-export const registerElectronCommands = (cli, logger, resultOutput) => {
+export const registerElectronCommands = (cli, logger, environment, resultOutput) => {
     registerElectronObservationCommands(cli, logger);
-    registerElectronActiveCommand(cli, logger);
+    registerElectronActiveCommand(cli, logger, environment);
     registerJavaScriptApplicationCommand(cli, logger, resultOutput);
     registerJavaScriptRuntimeReconciliationCommand(cli, logger);
 };
-const registerElectronActiveCommand = (cli, logger) => {
+const registerElectronActiveCommand = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.captureElectronScenario, {
-        description: "Run one bounded owned Electron scenario",
+        description: "Run one owned Electron scenario with cancellable actions",
         args: z.object({
             inputJson: z
                 .string()
                 .describe("Inline JSON or a JSON file matching capture_electron_scenario"),
         }),
-        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.captureElectronScenario, async () => {
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.captureElectronScenario, async () => {
             const input = await parseCliJsonInput(args.inputJson, "capture_electron_scenario");
             if (!input.ok)
                 return input.error;
@@ -39,9 +40,9 @@ const registerElectronActiveCommand = (cli, logger) => {
             if (!parsed.success)
                 return inputError("capture_electron_scenario", parsed.error.issues, input.value);
             const { createElectronScenarioProvider } = await import("../composition/electronScenario.js");
-            const result = await captureElectronScenario(createElectronScenarioProvider(), parsed.data);
+            const result = await captureElectronScenario(createElectronScenarioProvider(environment), parsed.data, { signal });
             return result.ok ? result.value : cliError(result.error);
-        }),
+        })),
     });
 };
 const registerJavaScriptRuntimeReconciliationCommand = (cli, logger) => {
@@ -113,13 +114,13 @@ const registerJavaScriptApplicationCommand = (cli, logger, resultOutput) => {
             path: z.string().describe("ASAR or extracted application path"),
         }),
         options: javascriptApplicationOptions,
-        run: ({ args, options, format }) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({ input_path: args.path, format: options.artifactFormat }, resultOutput === undefined
+        run: ({ args, options, format }) => withCommandCancellation((signal) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, () => runCliJavaScriptApplicationAnalysis({ input_path: args.path, format: options.artifactFormat }, resultOutput === undefined
             ? undefined
             : {
                 output: resultOutput,
                 command: CLI_COMMANDS.analyzeJavaScriptApplication,
                 format,
-            })),
+            }, signal))),
     });
 };
 const electronObservationContext = async () => {

package/dist/cli/interactiveSetup.js

@@ -53,13 +53,13 @@ export const renderSetupProgress = (event) => {
     writeLine(`${symbol}  ${event.label}${suffix}`);
 };
 /** Finish an interactive setup journey without exposing the full doctor catalog. */
-export const renderInteractiveSetupResult = (result) => {
+export const renderInteractiveSetupResult = (result, environment = process.env) => {
     if (result.status === "ready") {
         const changedClients = Object.entries(result.clients)
             .filter(([, client]) => client.status === "configured")
             .map(([client]) => clientDisplayNames.get(client) ?? client);
         const readyClients = readyAgentClients(result, changedClients);
-        renderReadyCapabilities(result, readyClients);
+        renderReadyCapabilities(result, readyClients, environment);
         outro(changedClients.length === 0
             ? "REA is ready for local app analysis."
             : `Restart ${changedClients.join(", ")} to load REA.`, promptStreams);
@@ -68,7 +68,7 @@ export const renderInteractiveSetupResult = (result) => {
     if (result.status === "planned" || result.status === "cancelled")
         return;
     writeLine(`!  ${result.remediation ?? "Setup needs attention."}`);
-    outro(`Run \`${cliInvocation()} doctor\` for the remaining checks.`, promptStreams);
+    outro(`Run \`${cliInvocation(environment)} doctor\` for the remaining checks.`, promptStreams);
 };
 const selectSetupActions = async (actions, accessible, context) => {
     const clientStates = context.clientStates.filter(({ client }) => client.format !== "unsupported");
@@ -167,8 +167,8 @@ const renderKeyboardHelp = (accessible) => {
         ? "│  Keys: Enter answer · Ctrl-C cancel"
         : "│  Keys: ↑/↓ navigate · Space toggle · Enter confirm · Ctrl-C cancel");
 };
-const cliInvocation = () => process.env.npm_command === "exec" ? "npx rea-agents" : "rea";
-const renderReadyCapabilities = (result, readyClients) => {
+const cliInvocation = (environment) => environment.npm_command === "exec" ? "npx rea-agents" : "rea";
+const renderReadyCapabilities = (result, readyClients, environment) => {
     writeLine("◆  What you can do now");
     const providers = readyProviders(result);
     if (providers.length > 0)
@@ -177,7 +177,7 @@ const renderReadyCapabilities = (result, readyClients) => {
         writeLine(`│  Agent access: ${humanList(readyClients)}`);
     if (result.doctor.identity?.skill.state === "aligned")
         writeLine("│  Guided reverse-engineering workflows: installed");
-    writeLine(`│  CLI: ${cliInvocation()} ${providers.length > 0 ? "analyze /path/to/app" : "capabilities"}`);
+    writeLine(`│  CLI: ${cliInvocation(environment)} ${providers.length > 0 ? "analyze /path/to/app" : "capabilities"}`);
     const firstClient = readyClients[0];
     if (firstClient !== undefined)
         writeLine(`│  Try in ${firstClient}: "Explain how a feature works in /path/to/app and show the evidence."`);

package/dist/cli/javascriptApplicationAnalysis.js

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

package/dist/cli/jsonOutput.js

@@ -1,6 +1,7 @@
+import { bufferedJsonParts, jsonParts } from "../domain/jsonSerialization.js";
 /** Write ordinary JSON without constructing a document-sized string. */
 export const writeJsonOutput = async (value, destination, format = "json") => {
-    for (const part of bufferedParts(documentParts(value, format)))
+    for (const part of bufferedJsonParts(documentParts(value, format)))
         await writePart(destination, part);
 };
 const writePart = (destination, part) => new Promise((resolve, reject) => {
@@ -27,107 +28,11 @@ const writePart = (destination, part) => new Promise((resolve, reject) => {
 function* documentParts(value, format) {
     if (format === "jsonl" && Array.isArray(value)) {
         for (const item of value) {
-            yield* encodeValue(item, false, 0, new Set());
+            yield* jsonParts(item);
             yield "\n";
         }
         return;
     }
-    yield* encodeValue(value, format === "json", 0, new Set());
+    yield* jsonParts(value, format === "json");
     yield "\n";
 }
-function* bufferedParts(parts) {
-    let buffer = "";
-    for (const part of parts) {
-        if (buffer.length + part.length > 64 * 1024 && buffer !== "") {
-            yield buffer;
-            buffer = "";
-        }
-        buffer += part;
-    }
-    if (buffer !== "")
-        yield buffer;
-}
-function* encodeString(value) {
-    if (value.length <= 8192) {
-        yield JSON.stringify(value);
-        return;
-    }
-    yield '"';
-    for (let start = 0; start < value.length;) {
-        let end = Math.min(start + 8192, value.length);
-        const last = value.charCodeAt(end - 1);
-        const next = value.charCodeAt(end);
-        // Keep a surrogate pair in the same JSON.stringify and UTF-8 write.
-        if (end < value.length &&
-            last >= 0xd800 &&
-            last <= 0xdbff &&
-            next >= 0xdc00 &&
-            next <= 0xdfff)
-            end -= 1;
-        yield JSON.stringify(value.slice(start, end)).slice(1, -1);
-        start = end;
-    }
-    yield '"';
-}
-function* encodeValue(value, pretty, depth, ancestors) {
-    if (typeof value === "string") {
-        yield* encodeString(value);
-        return;
-    }
-    if (value === null || typeof value === "boolean") {
-        yield value === null ? "null" : String(value);
-        return;
-    }
-    if (typeof value === "number" && Number.isFinite(value)) {
-        yield String(value);
-        return;
-    }
-    if (typeof value !== "object" || value === null)
-        throw new TypeError("CLI JSON output requires ordinary JSON values");
-    if (ancestors.has(value))
-        throw new TypeError("CLI JSON output contains a circular reference");
-    if (!Array.isArray(value) &&
-        Object.prototype.toString.call(value) !== "[object Object]")
-        throw new TypeError("CLI JSON output requires ordinary JSON objects");
-    ancestors.add(value);
-    try {
-        const array = Array.isArray(value);
-        const keys = array
-            ? undefined
-            : Object.keys(value).filter((key) => {
-                const item = Reflect.get(value, key);
-                // Incur's filter can select inherited methods. Match native JSON's
-                // omission of fields that have no JSON representation.
-                return (item !== undefined &&
-                    typeof item !== "function" &&
-                    typeof item !== "symbol");
-            });
-        const count = array ? value.length : (keys?.length ?? 0);
-        yield array ? "[" : "{";
-        for (let index = 0; index < count; index += 1) {
-            if (index > 0)
-                yield ",";
-            if (pretty)
-                yield `\n${"  ".repeat(depth + 1)}`;
-            let item;
-            if (array) {
-                item = value[index];
-            }
-            else {
-                const key = keys?.[index];
-                if (key === undefined)
-                    throw new TypeError("CLI JSON object changed during serialization");
-                yield* encodeString(key);
-                yield pretty ? ": " : ":";
-                item = Reflect.get(value, key);
-            }
-            yield* encodeValue(item, pretty, depth + 1, ancestors);
-        }
-        if (pretty && count > 0)
-            yield `\n${"  ".repeat(depth)}`;
-        yield array ? "]" : "}";
-    }
-    finally {
-        ancestors.delete(value);
-    }
-}

package/dist/cli/managedCommands.js

@@ -2,22 +2,21 @@ import { z } from "incur";
 import { compareManagedMemberPaths } from "../application/managed/ManagedMemberComparisonService.js";
 import { verifyManagedNativeBoundariesEvidence } from "../application/managed/ManagedNativeVerificationService.js";
 import { importManagedReconstructionEvidence } from "../application/managed/ManagedReconstructionService.js";
-import { runProviderAnalysis } from "../composition/directAnalysis.js";
 import { parseCliJsonInput } from "../cliJsonInput.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { registerProjectManagedApplicationGraph } from "./managedProjectGraphCommand.js";
-export const registerManagedCommands = (cli, logger) => {
-    registerInspectManagedArtifact(cli, logger);
-    registerInspectManagedMembers(cli, logger);
-    registerInspectManagedNativeBoundaries(cli, logger);
+export const registerManagedCommands = (cli, logger, runProviderAnalysis) => {
+    registerInspectManagedArtifact(cli, logger, runProviderAnalysis);
+    registerInspectManagedMembers(cli, logger, runProviderAnalysis);
+    registerInspectManagedNativeBoundaries(cli, logger, runProviderAnalysis);
     registerCompareManagedMembers(cli, logger);
     registerImportManagedReconstruction(cli, logger);
     registerVerifyManagedNativeBoundaries(cli, logger);
     registerProjectManagedApplicationGraph(cli, logger);
 };
-const registerInspectManagedArtifact = (cli, logger) => {
+const registerInspectManagedArtifact = (cli, logger, runProviderAnalysis) => {
     cli.command(CLI_COMMANDS.inspectManagedArtifact, {
         description: "Inspect PE/CLI identity without loading target code",
         args: z.object({
@@ -26,7 +25,7 @@ const registerInspectManagedArtifact = (cli, logger) => {
         run: ({ args }) => logCliCommand(logger, "inspect-managed-artifact", () => runProviderAnalysis(args.path, "inspect_managed_artifact", {}, logger)),
     });
 };
-const registerInspectManagedMembers = (cli, logger) => {
+const registerInspectManagedMembers = (cli, logger, runProviderAnalysis) => {
     cli.command(CLI_COMMANDS.inspectManagedMembers, {
         description: "Inspect PE/CLI metadata members, signatures, and CIL anchors without loading target code",
         args: z.object({
@@ -35,7 +34,7 @@ const registerInspectManagedMembers = (cli, logger) => {
         run: ({ args }) => logCliCommand(logger, "inspect-managed-members", () => runProviderAnalysis(args.path, "inspect_managed_members", {}, logger)),
     });
 };
-const registerInspectManagedNativeBoundaries = (cli, logger) => {
+const registerInspectManagedNativeBoundaries = (cli, logger, runProviderAnalysis) => {
     cli.command(CLI_COMMANDS.inspectManagedNativeBoundaries, {
         description: "Inspect PE/CLI PInvoke and native implementation boundary declarations without loading target code",
         args: z.object({

package/dist/cli/nativeCallCommands.js

@@ -1,16 +1,14 @@
 import { z } from "incur";
-import { runProviderAnalysis } from "../composition/directAnalysis.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { parseCliJsonInput } from "../cliJsonInput.js";
 import { logCliCommand } from "../cliLogging.js";
-import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
+import { analysisInputErrorFromIssues } from "../domain/inputIssueProjection.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { nativeCallObservationInputSchema } from "../domain/native/nativeCallObservation.js";
 const OPERATION = "observe_native_calls";
 /** `observe-native-calls <path> <input-json>`: the MCP input object as JSON. */
-export const registerNativeCallCommands = (cli, logger) => {
+export const registerNativeCallCommands = (cli, logger, runProviderAnalysis) => {
     cli.command(CLI_COMMANDS.observeNativeCalls, {
         description: "Launch a Mach-O under LLDB and record entries into selected functions or Objective-C methods",
         args: z.object({
@@ -27,7 +25,7 @@ export const registerNativeCallCommands = (cli, logger) => {
             if (!parsed.success)
                 return {
                     error: "Analysis failed",
-                    ...projectAnalysisError(new AnalysisInputError(OPERATION, undefined, projectInputIssues(parsed.error.issues, input.value))),
+                    ...projectAnalysisError(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, input.value)),
                 };
             return runProviderAnalysis(args.path, OPERATION, z.record(z.string(), jsonValueSchema).parse(parsed.data), logger);
         }),

package/dist/cli/omittableDefaults.js

@@ -0,0 +1,50 @@
+import { Cli, z } from "incur";
+const INPUT_GROUPS = ["args", "env", "options"];
+// Incur types its router key without vars, env, or globals; accept any CLI.
+const registeredCommands = Cli.toCommands;
+/**
+ * Advertise parser-filled defaults as omittable CLI inputs.
+ *
+ * Incur derives `--schema`, the `--llms` manifests, and help synopses from
+ * Zod's output view, where a defaulted field always has a value and is
+ * therefore listed as required. Callers may omit such a field, so each one is
+ * wrapped as optional while its default, constraints, metadata, and parsed
+ * value stay unchanged.
+ */
+export const presentOmittableDefaults = (cli) => {
+    const commands = registeredCommands.get(cli);
+    if (commands !== undefined)
+        presentCommands(commands);
+};
+const presentCommands = (commands) => {
+    for (const entry of commands.values()) {
+        if ("_group" in entry) {
+            presentCommands(entry.commands);
+            if (entry.root !== undefined)
+                presentInputs(entry.root);
+        }
+        else if (!("_alias" in entry) && !("_fetch" in entry))
+            presentInputs(entry);
+    }
+};
+const presentInputs = (command) => {
+    for (const group of INPUT_GROUPS) {
+        const schema = command[group];
+        if (schema instanceof z.ZodObject)
+            command[group] = withOmittableDefaults(schema);
+    }
+};
+const withOmittableDefaults = (schema) => {
+    const omittable = Object.entries(schema.shape).filter(([, field]) => fillsOmission(field));
+    if (omittable.length === 0)
+        return schema;
+    return schema.safeExtend(Object.fromEntries(omittable.map(([key, field]) => [key, optionalWithMetadata(field)])));
+};
+/** Zod accepts an omitted value (`optin`) but always produces one (`optout`). */
+const fillsOmission = (field) => field._zod.optin === "optional" && field._zod.optout === undefined;
+const optionalWithMetadata = (field) => {
+    const metadata = field.meta();
+    return metadata === undefined
+        ? field.optional()
+        : field.optional().meta(metadata);
+};

package/dist/cli/processCommands.js

@@ -2,12 +2,13 @@ import { Cli, z } from "incur";
 import { captureProcessScenarioFile, compareProcessEvidenceFiles, isProcessCliFailure, } from "../application/process/ProcessCli.js";
 import { logCliCommand } from "../cliLogging.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { withCommandCancellation } from "./commandCancellation.js";
 /** Register direct process capture and comparison commands. */
-export const registerProcessCommands = (cli, logger, environment = process.env) => {
+export const registerProcessCommands = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.captureProcess, {
         description: "Capture one caller-selected process scenario",
         args: z.object({ scenario: z.string().describe("Scenario JSON path") }),
-        run: ({ args }) => logCliCommand(logger, "capture-process", () => captureProcessScenarioFile(args.scenario, environment), isProcessCliFailure),
+        run: ({ args }) => withCommandCancellation((signal) => logCliCommand(logger, "capture-process", () => captureProcessScenarioFile(args.scenario, environment, signal), isProcessCliFailure)),
     });
     cli.command(CLI_COMMANDS.compareProcessCaptures, {
         description: "Compare two process capture Evidence JSON files",

package/dist/cli/setupCommands.js

@@ -3,7 +3,8 @@ import { DOCTOR_PROVIDER_IDS, runDoctor, } from "../application/Doctor.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 { isUninstallFailure, runUninstall, systemUninstallHost, } from "../application/Uninstall.js";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 import { isUpdateFailure, runUpdate } from "../application/Update.js";
 import { systemUpdateHost } from "../application/UpdateRuntime.js";
 import { confirmInteractiveSetup, renderInteractiveSetupResult, renderSetupProgress, } from "./interactiveSetup.js";
@@ -17,12 +18,12 @@ const supportedClientSchema = z
     .string()
     .refine((candidate) => supportedClientIds.some((name) => name === candidate), "Unsupported agent integration");
 /** Register setup, doctor, uninstall, and update CLI commands. */
-export const registerSetupCommands = (cli, logger) => {
-    registerSetupCommand(cli, logger);
-    registerDoctorCommand(cli, logger);
-    registerMaintenanceCommands(cli, logger);
+export const registerSetupCommands = (cli, logger, environment) => {
+    registerSetupCommand(cli, logger, environment);
+    registerDoctorCommand(cli, logger, environment);
+    registerMaintenanceCommands(cli, logger, environment);
 };
-const registerSetupCommand = (cli, logger) => {
+const registerSetupCommand = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.setup, {
         description: "Configure agent integrations and optional analysis providers",
         outputPolicy: "agent-only",
@@ -57,10 +58,10 @@ const registerSetupCommand = (cli, logger) => {
                 .describe("Use sequential accessible setup prompts"),
         }),
         alias: { yes: "y" },
-        run: ({ options, formatExplicit }) => logCliCommand(logger, CLI_COMMANDS.setup, () => runSetupCommand({ options, formatExplicit }), isSetupFailure),
+        run: ({ options, formatExplicit }) => logCliCommand(logger, CLI_COMMANDS.setup, () => runSetupCommand({ options, formatExplicit }, environment), isSetupFailure),
     });
 };
-const registerDoctorCommand = (cli, logger) => {
+const registerDoctorCommand = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.doctor, {
         description: "Check whether REA is ready",
         options: z.object({
@@ -78,10 +79,10 @@ const registerDoctorCommand = (cli, logger) => {
                 .optional()
                 .describe("Require the installed REA skill identity to be aligned"),
         }),
-        run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target, createSystemDoctorHost(), doctorScope(options))),
+        run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target, createSystemDoctorHost(environment), doctorScope(options))),
     });
 };
-const registerMaintenanceCommands = (cli, logger) => {
+const registerMaintenanceCommands = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.uninstall, {
         description: "Remove REA-owned agent configuration and skill files",
         options: z.object({
@@ -91,22 +92,22 @@ const registerMaintenanceCommands = (cli, logger) => {
                 .describe("Also remove REA caches and state"),
         }),
         alias: { purgeData: "purge-data" },
-        run: ({ options }) => logCliCommand(logger, "uninstall", () => runUninstall(options.purgeData), isUninstallFailure),
+        run: ({ options }) => logCliCommand(logger, "uninstall", () => runUninstall(options.purgeData, systemUninstallHost(homeDirectoryFromEnvironment(environment, process.platform), undefined, environment)), isUninstallFailure),
     });
     cli.command(CLI_COMMANDS.update, {
         description: "Update this REA installation and verify the installed release",
-        run: ({ formatExplicit }) => logCliCommand(logger, CLI_COMMANDS.update, () => runUpdate(PRODUCT_IDENTITY.packageVersion, systemUpdateHost(), formatExplicit ? "structured" : "human"), isUpdateFailure),
+        run: ({ formatExplicit }) => logCliCommand(logger, CLI_COMMANDS.update, () => runUpdate(PRODUCT_IDENTITY.packageVersion, systemUpdateHost(undefined, undefined, environment), formatExplicit ? "structured" : "human"), isUpdateFailure),
     });
 };
-const runSetupCommand = async (input) => {
+const runSetupCommand = async (input, environment) => {
     const { options } = input;
     const interactive = setupIsInteractive(options, input.formatExplicit);
     const hasExplicitScope = setupHasExplicitScope(options);
-    const result = await runSetup(setupRunOptions(input, interactive, hasExplicitScope), systemSetupHost(createSystemDoctorHost()), interactive
+    const result = await runSetup(setupRunOptions(input, interactive, hasExplicitScope), systemSetupHost(createSystemDoctorHost(environment), environment), interactive
         ? (actions, context) => confirmInteractiveSetup(actions, options.accessible, context)
         : undefined);
     if (interactive)
-        renderInteractiveSetupResult(result);
+        renderInteractiveSetupResult(result, environment);
     return result;
 };
 const setupRunOptions = (input, interactive, hasExplicitScope) => {

package/dist/cli/utilityCommands.js

@@ -1,8 +1,7 @@
 import { z } from "incur";
-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 { parseConfig } from "../config/parseConfig.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { AnalysisInputError } from "../domain/analysisErrorCore.js";
 import { projectInputIssues } from "../domain/inputIssueProjection.js";
@@ -14,10 +13,11 @@ import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { swiftSymbolsSchema } from "../contracts/native/nativeToolContracts.js";
 import { isReferenceSourceImportCliFailure } from "./referenceSourceImportStatus.js";
 import { registerNativeCallCommands } from "./nativeCallCommands.js";
-export const registerUtilityCommands = (cli, logger, environment = process.env) => {
-    registerCapabilityCommands(cli, logger);
-    registerNativeCommands(cli, logger);
-    registerNativeCallCommands(cli, logger);
+export const registerUtilityCommands = (cli, logger, environment, analysis) => {
+    const { runProviderAnalysis } = analysis;
+    registerCapabilityCommands(cli, logger, analysis);
+    registerNativeCommands(cli, logger, runProviderAnalysis);
+    registerNativeCallCommands(cli, logger, runProviderAnalysis);
     for (const [command, operation] of [
         [CLI_COMMANDS.observeNativeUi, "observe_native_ui"],
         [CLI_COMMANDS.captureNativeUiScenario, "capture_native_ui_scenario"],
@@ -97,7 +97,7 @@ const invalidNativeUiScenarioInput = (operation, issues) => ({
     error: "Application workflow failed",
     ...projectAnalysisError(new AnalysisInputError(operation, undefined, issues)),
 });
-const registerCapabilityCommands = (cli, logger) => {
+const registerCapabilityCommands = (cli, logger, { runProviderStatus, runCapabilityStatus, }) => {
     for (const command of [
         CLI_COMMANDS.capabilities,
         CLI_COMMANDS.providers,
@@ -112,7 +112,7 @@ const registerCapabilityCommands = (cli, logger) => {
         });
     }
 };
-const registerNativeCommands = (cli, logger) => {
+const registerNativeCommands = (cli, logger, runProviderAnalysis) => {
     for (const [command, tool] of [
         [CLI_COMMANDS.inspectMacho, "inspect_macho"],
         [CLI_COMMANDS.inspectSignature, "inspect_signature"],
@@ -147,7 +147,7 @@ const registerNativeCommands = (cli, logger) => {
         run: ({ args }) => logCliCommand(logger, "demangle-swift", () => runProviderAnalysis(args.path, "demangle_swift", { symbols: args.symbols }, logger)),
     });
 };
-const registerReferenceSourceCommand = (cli, logger, environment = process.env) => {
+const registerReferenceSourceCommand = (cli, logger, environment) => {
     cli.command(CLI_COMMANDS.importReferenceSource, {
         description: "Import a source tree as historical reference only",
         args: z.object({

package/dist/cli/webRuntimeCommands.js

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

package/dist/cli.js

@@ -1,8 +1,12 @@
+import { snapshotEnvironment } from "./process/snapshotEnvironment.js";
+import { createDirectAnalysis } from "./composition/directAnalysis.js";
 import { registerEvmCommands } from "./cli/evmCommands.js";
+import { registerAnalysisViewCommands } from "./cli/analysisViewCommands.js";
 import { registerBinaryDiagnosticsCommands } from "./cli/binaryDiagnosticsCommands.js";
 import { Cli } from "incur";
 import { createLogger, parseLogLevel } from "./logger.js";
 import { PRODUCT_IDENTITY } from "./identity.js";
+import { npxRegistrationCommand } from "./application/ClientRegistrationIdentity.js";
 import { registerSetupCommands } from "./cli/setupCommands.js";
 import { registerCoreAnalysisCommands } from "./cli/coreAnalysisCommands.js";
 import { registerUtilityCommands } from "./cli/utilityCommands.js";
@@ -24,12 +28,15 @@ import { registerBrowserScenarioCommands } from "./cliBrowserScenarioCommands.js
 import { registerElectronCommands } from "./cli/electronCommands.js";
 import { registerJavaScriptRuntimeObservationCommands } from "./cliJavaScriptRuntimeCommands.js";
 import { registerApplicationCommands } from "./cli/applicationCommands.js";
+import { presentOmittableDefaults } from "./cli/omittableDefaults.js";
 /**
  * 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 = (environment = process.env, resultOutput) => {
+export const createCli = (selectedEnvironment = process.env, resultOutput) => {
+    const environment = snapshotEnvironment(selectedEnvironment);
+    const analysis = createDirectAnalysis(environment);
     const logger = createLogger("cli", environment.REA_LOG_LEVEL === undefined
         ? "silent"
         : parseLogLevel(environment.REA_LOG_LEVEL));
@@ -37,20 +44,21 @@ export const createCli = (environment = process.env, resultOutput) => {
         version: PRODUCT_IDENTITY.packageVersion,
         description: "Reverse engineer anything from your terminal or agent.",
         mcp: {
-            command: PRODUCT_IDENTITY.mcpCommand,
+            command: npxRegistrationCommand().join(" "),
             instructions: "Ask what software, artifact, protocol, or behavior the user wants to understand, then choose the available investigation capabilities that can produce evidence.",
         },
         sync: false,
     });
-    registerSetupCommands(cli, logger);
-    registerCoreAnalysisCommands(cli, logger, resultOutput);
-    registerUtilityCommands(cli, logger, environment);
+    registerSetupCommands(cli, logger, environment);
+    registerCoreAnalysisCommands(cli, logger, analysis.runDirectAnalysis, resultOutput);
+    registerUtilityCommands(cli, logger, environment, analysis);
     registerEvmCommands(cli, logger, environment);
-    registerArtifactCommands(cli, logger);
-    registerManagedCommands(cli, logger);
+    registerArtifactCommands(cli, logger, analysis.runProviderAnalysis);
+    registerManagedCommands(cli, logger, analysis.runProviderAnalysis);
     registerAndroidCommands(cli, logger, environment);
     registerFirmwareCommands(cli, logger, environment);
     registerBinaryDiagnosticsCommands(cli, logger, environment);
+    registerAnalysisViewCommands(cli, logger);
     registerEvidenceCommands(cli, logger);
     registerProcessCommands(cli, logger, environment);
     registerBrowserCommands(cli, logger);
@@ -61,9 +69,10 @@ export const createCli = (environment = process.env, resultOutput) => {
     registerWebNetworkCaptureCommands(cli, logger, environment);
     registerJavaScriptRecoveryCommands(cli, logger, environment);
     registerAdvancedBrowserCommands(cli, logger);
-    registerBrowserScenarioCommands(cli, logger);
-    registerElectronCommands(cli, logger, resultOutput);
+    registerBrowserScenarioCommands(cli, logger, environment);
+    registerElectronCommands(cli, logger, environment, resultOutput);
     registerJavaScriptRuntimeObservationCommands(cli, logger);
     registerApplicationCommands(cli, logger);
+    presentOmittableDefaults(cli);
     return cli;
 };