rea-agents 1.6.0 → 2.0.0

package/dist/cliApplicationCommands.js

@@ -0,0 +1,62 @@
+import { Cli, z } from "incur";
+import { compareApplicationVersionsEvidence, traceApplicationFeatureEvidence, } from "./application/JavaScriptApplicationWorkflowService.js";
+import { runControlledReplay } from "./application/JavaScriptReplayService.js";
+import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
+import { parseCliJsonInput } from "./cliJsonInput.js";
+import { logCliCommand } from "./cliLogging.js";
+import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
+import { parseConfig } from "./config.js";
+import { LinuxJavaScriptReplayRunner } from "./replay/LinuxJavaScriptReplayRunner.js";
+import { SystemJavaScriptReplayHost } from "./replay/SystemJavaScriptReplayHost.js";
+/** Register CLI equivalents of provider-neutral application graph workflows. */
+export const registerApplicationCommands = (cli, logger) => {
+    registerJsonCommand(cli, logger, CLI_COMMANDS.traceApplicationFeature, "Trace a typed seed through authenticated application Evidence JSON", traceApplicationFeatureEvidence);
+    registerJsonCommand(cli, logger, CLI_COMMANDS.compareApplicationVersions, "Compare two authenticated JavaScript Application Graph versions", compareApplicationVersionsEvidence);
+    cli.command(CLI_COMMANDS.runControlledReplay, {
+        description: "Plan or execute an approved extracted-module replay in the Linux sandbox",
+        args: z.object({
+            inputJson: z.string().describe("Inline replay JSON or JSON file path"),
+        }),
+        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.runControlledReplay, async () => {
+            const input = await parseCliJsonInput(args.inputJson, CLI_COMMANDS.runControlledReplay);
+            if (!input.ok)
+                return input.error;
+            const config = parseConfig(process.env);
+            if (!config.ok)
+                return projectAnalysisError(config.error);
+            const authority = await loadConfiguredPermissionAuthority(config.value);
+            if (!authority.ok)
+                return projectAnalysisError(authority.error);
+            const result = await runControlledReplay({
+                policy: config.value.javascriptReplayPolicy,
+                host: new SystemJavaScriptReplayHost(),
+                runner: new LinuxJavaScriptReplayRunner(),
+                authority: authority.value,
+            }, input.value);
+            return result.ok ? result.value : projectAnalysisError(result.error);
+        }),
+    });
+};
+const registerJsonCommand = (cli, logger, name, description, workflow) => {
+    cli.command(name, {
+        description,
+        args: z.object({
+            inputJson: z.string().describe("Inline workflow JSON or JSON file path"),
+        }),
+        run: ({ args }) => logCliCommand(logger, name, async () => {
+            const input = await parseCliJsonInput(args.inputJson, name);
+            if (!input.ok)
+                return input.error;
+            const result = workflow(input.value);
+            return result.ok
+                ? result.value
+                : {
+                    error: "Application workflow failed",
+                    ...projectAnalysisError(result.error instanceof AnalysisInputError
+                        ? result.error
+                        : new AnalysisInputError(name)),
+                };
+        }),
+    });
+};

package/dist/cliBrowserAdvancedCommands.js

@@ -8,6 +8,7 @@ import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
 import { compareWebCapturesInputSchema } from "./domain/webCaptureDiff.js";
 import { discoverWebMcpToolsInputSchema } from "./domain/webMcpDiscovery.js";
 import { captureWebScreenshotInputSchema, compareWebScreenshotsInputSchema, } from "./domain/webScreenshot.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
 const scopeOptions = {
     allowedOrigins: z.array(z.string().min(1)).optional(),
     approved: z.boolean().default(false),
@@ -20,7 +21,7 @@ export const registerAdvancedBrowserCommands = (cli, logger) => {
     registerScreenshotDiff(cli, logger);
 };
 const registerWebMcp = (cli, logger) => {
-    cli.command("discover-webmcp-tools", {
+    cli.command(CLI_COMMANDS.discoverWebMcpTools, {
         description: "Passively discover page-declared WebMCP tools",
         args: z.object({ endpoint: z.string(), targetId: z.string() }),
         options: z.object({
@@ -59,7 +60,7 @@ const registerWebMcp = (cli, logger) => {
     });
 };
 const registerCaptureDiff = (cli, logger) => {
-    cli.command("compare-web-captures", {
+    cli.command(CLI_COMMANDS.compareWebCaptures, {
         description: "Compare two normalized web capture JSON values",
         args: z.object({ beforeJson: z.string(), afterJson: z.string() }),
         options: z.object({
@@ -81,7 +82,7 @@ const registerCaptureDiff = (cli, logger) => {
     });
 };
 const registerScreenshot = (cli, logger) => {
-    cli.command("capture-web-screenshot", {
+    cli.command(CLI_COMMANDS.captureWebScreenshot, {
         description: "Capture an explicitly approved visible page viewport",
         args: z.object({ endpoint: z.string(), targetId: z.string() }),
         options: z.object({
@@ -114,7 +115,7 @@ const registerScreenshot = (cli, logger) => {
     });
 };
 const registerScreenshotDiff = (cli, logger) => {
-    cli.command("compare-web-screenshots", {
+    cli.command(CLI_COMMANDS.compareWebScreenshots, {
         description: "Compare two self-verifying PNG artifact JSON values",
         args: z.object({ beforeJson: z.string(), afterJson: z.string() }),
         options: z.object({

package/dist/cliBrowserCommands.js

@@ -8,6 +8,7 @@ import { inspectWebPageInputSchema, listBrowserTargetsInputSchema, } from "./dom
 import { analyzeWebBundleInputSchema } from "./domain/webBundleAnalysis.js";
 import { observeWebSessionInputSchema } from "./domain/browserSession.js";
 import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
 const browserScopeOptions = {
     allowedOrigins: z
         .array(z.string().min(1))
@@ -23,7 +24,7 @@ export const registerBrowserCommands = (cli, logger) => {
     registerObservationSession(cli, logger);
 };
 const registerTargetList = (cli, logger) => {
-    cli.command("list-browser-targets", {
+    cli.command(CLI_COMMANDS.listBrowserTargets, {
         description: "List approved pages from a user-owned loopback CDP browser",
         args: z.object({
             endpoint: z.string().describe("Configured loopback CDP HTTP endpoint"),
@@ -52,7 +53,7 @@ const registerTargetList = (cli, logger) => {
     });
 };
 const registerPageInspection = (cli, logger) => {
-    cli.command("inspect-web-page", {
+    cli.command(CLI_COMMANDS.inspectWebPage, {
         description: "Passively inspect one approved page through CDP",
         args: z.object({
             endpoint: z.string().describe("Configured loopback CDP HTTP endpoint"),
@@ -195,7 +196,7 @@ const registerPageInspection = (cli, logger) => {
     });
 };
 const registerBundleAnalysis = (cli, logger) => {
-    cli.command("analyze-web-bundle", {
+    cli.command(CLI_COMMANDS.analyzeWebBundle, {
         description: "Capture and statically analyze an approved page bundle",
         args: z.object({
             endpoint: z.string().describe("Configured loopback CDP HTTP endpoint"),
@@ -262,7 +263,7 @@ const registerBundleAnalysis = (cli, logger) => {
     });
 };
 const registerObservationSession = (cli, logger) => {
-    cli.command("observe-web-session", {
+    cli.command(CLI_COMMANDS.observeWebSession, {
         description: "Observe user-driven page navigation during a bounded window",
         args: z.object({
             endpoint: z.string().describe("Configured loopback CDP HTTP endpoint"),

package/dist/cliCommandNames.js

@@ -0,0 +1,56 @@
+/** Canonical names used by every one-shot CLI command registration. */
+export const CLI_COMMANDS = Object.freeze({
+    analyze: "analyze",
+    inspect: "inspect",
+    decompile: "decompile",
+    setup: "setup",
+    doctor: "doctor",
+    uninstall: "uninstall",
+    upgrade: "upgrade",
+    xrefs: "xrefs",
+    trace: "trace",
+    capabilities: "capabilities",
+    providers: "providers",
+    function: "function",
+    search: "search",
+    importReferenceSource: "import-reference-source",
+    inventoryArtifact: "inventory-artifact",
+    extractArtifact: "extract-artifact",
+    inspectManagedArtifact: "inspect-managed-artifact",
+    inspectManagedMembers: "inspect-managed-members",
+    inspectManagedNativeBoundaries: "inspect-managed-native-boundaries",
+    compareManagedMembers: "compare-managed-members",
+    verifyManagedNativeBoundaries: "verify-managed-native-boundaries",
+    importManagedReconstruction: "import-managed-reconstruction",
+    planManagedRuntimeCorrelation: "plan-managed-runtime-correlation",
+    projectManagedApplicationGraph: "project-managed-application-graph",
+    inspectMacho: "inspect-macho",
+    inspectSignature: "inspect-signature",
+    listArchitectures: "list-architectures",
+    inspectPlist: "inspect-plist",
+    demangleSwift: "demangle-swift",
+    evidenceImport: "evidence-import",
+    evidenceExport: "evidence-export",
+    compare: "compare",
+    investigateVersions: "investigate-versions",
+    captureProcess: "capture-process",
+    compareProcessCaptures: "compare-process-captures",
+    policy: "policy",
+    listBrowserTargets: "list-browser-targets",
+    inspectWebPage: "inspect-web-page",
+    analyzeWebBundle: "analyze-web-bundle",
+    observeWebSession: "observe-web-session",
+    discoverWebMcpTools: "discover-webmcp-tools",
+    compareWebCaptures: "compare-web-captures",
+    captureWebScreenshot: "capture-web-screenshot",
+    compareWebScreenshots: "compare-web-screenshots",
+    listElectronTargets: "list-electron-targets",
+    inspectElectronPage: "inspect-electron-page",
+    analyzeJavaScriptApplication: "analyze-javascript-application",
+    reconcileJavaScriptRuntime: "reconcile-javascript-runtime",
+    traceApplicationFeature: "trace-application-feature",
+    compareApplicationVersions: "compare-application-versions",
+    runControlledReplay: "run-controlled-replay",
+});
+/** Ordered primary CLI inventory; aliases are intentionally excluded. */
+export const CLI_COMMAND_NAMES = Object.freeze(Object.values(CLI_COMMANDS));

package/dist/cliElectronCommands.js

@@ -1,11 +1,16 @@
 import { Cli, z } from "incur";
 import { inspectElectronPage, listElectronTargets, } from "./application/ElectronObservationService.js";
+import { analyzeJavaScriptApplication } from "./application/JavaScriptApplicationService.js";
+import { reconcileJavaScriptRuntimeEvidence } from "./application/JavaScriptRuntimeReconciliationService.js";
 import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
 import { CdpElectronProvider } from "./browser/CdpElectronProvider.js";
 import { logCliCommand } from "./cliLogging.js";
 import { parseConfig } from "./config.js";
 import { inspectElectronPageInputSchema, listElectronTargetsInputSchema, } from "./domain/electronObservation.js";
+import { analyzeJavaScriptApplicationInputSchema } from "./domain/javascriptApplicationAnalysis.js";
 import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
+import { parseCliJsonInput } from "./cliJsonInput.js";
 const scopeOptions = {
     allowedFileRoots: z
         .array(z.string().min(1))
@@ -15,7 +20,29 @@ const scopeOptions = {
 };
 /** Register CLI equivalents of the Electron MCP tools. */
 export const registerElectronCommands = (cli, logger) => {
-    cli.command("list-electron-targets", {
+    registerElectronObservationCommands(cli, logger);
+    registerJavaScriptApplicationCommand(cli, logger);
+    registerJavaScriptRuntimeReconciliationCommand(cli, logger);
+};
+const registerJavaScriptRuntimeReconciliationCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.reconcileJavaScriptRuntime, {
+        description: "Reconcile static application and passive runtime Evidence JSON",
+        args: z.object({
+            inputJson: z
+                .string()
+                .describe("Inline JSON or a JSON file path matching reconcile_javascript_runtime"),
+        }),
+        run: ({ args }) => logCliCommand(logger, CLI_COMMANDS.reconcileJavaScriptRuntime, async () => {
+            const input = await parseCliJsonInput(args.inputJson, "reconcile_javascript_runtime");
+            if (!input.ok)
+                return input.error;
+            const result = reconcileJavaScriptRuntimeEvidence(input.value);
+            return result.ok ? result.value : cliError(result.error);
+        }),
+    });
+};
+const registerElectronObservationCommands = (cli, logger) => {
+    cli.command(CLI_COMMANDS.listElectronTargets, {
         description: "List root-confined file pages from Electron CDP",
         args: z.object({ endpoint: z.string() }),
         options: z.object({
@@ -40,7 +67,7 @@ export const registerElectronCommands = (cli, logger) => {
             return result.ok ? result.value : cliError(result.error);
         }),
     });
-    cli.command("inspect-electron-page", {
+    cli.command(CLI_COMMANDS.inspectElectronPage, {
         description: "Passively inspect one root-confined Electron file page",
         args: z.object({ endpoint: z.string(), targetId: z.string() }),
         options: z.object({
@@ -52,6 +79,7 @@ export const registerElectronCommands = (cli, logger) => {
             maxDomNodes: z.number().int().min(1).max(10_000).default(2_000),
             maxScripts: z.number().int().min(1).max(2_000).default(500),
             maxResources: z.number().int().min(1).max(10_000).default(2_000),
+            maxWorkers: z.number().int().min(1).max(5_000).default(500),
             maxScriptSourceBytes: z
                 .number()
                 .int()
@@ -82,6 +110,7 @@ export const registerElectronCommands = (cli, logger) => {
                     max_dom_nodes: options.maxDomNodes,
                     max_scripts: options.maxScripts,
                     max_resources: options.maxResources,
+                    max_workers: options.maxWorkers,
                     max_script_source_bytes: options.maxScriptSourceBytes,
                     max_total_script_source_bytes: options.maxTotalScriptSourceBytes,
                 },
@@ -93,6 +122,80 @@ export const registerElectronCommands = (cli, logger) => {
         }),
     });
 };
+const registerJavaScriptApplicationCommand = (cli, logger) => {
+    cli.command(CLI_COMMANDS.analyzeJavaScriptApplication, {
+        description: "Statically reconstruct an approved JavaScript/Electron application",
+        args: z.object({
+            path: z.string().describe("Absolute ASAR or extracted application path"),
+        }),
+        options: z.object({
+            approved: z.boolean().default(false),
+            format: z.enum(["auto", "asar", "directory"]).default("auto"),
+            sourceMapReadApproved: z.boolean().default(false),
+            maxEntries: z.number().int().min(1).default(8_000),
+            maxTotalArtifactBytes: z
+                .number()
+                .int()
+                .min(1)
+                .default(512 * 1_024 * 1_024),
+            maxArtifactEntryBytes: z
+                .number()
+                .int()
+                .min(1)
+                .default(128 * 1_024 * 1_024),
+            maxCompressionRatio: z.number().min(1).default(1_000),
+            maxDepth: z.number().int().min(1).default(64),
+            maxPathBytes: z.number().int().min(1).default(4_096),
+            maxTextFiles: z.number().int().min(1).default(5_000),
+            maxTotalTextBytes: z
+                .number()
+                .int()
+                .min(1)
+                .default(128 * 1_024 * 1_024),
+            maxTextFileBytes: z
+                .number()
+                .int()
+                .min(1)
+                .default(8 * 1_024 * 1_024),
+            maxAstNodes: z.number().int().min(1).default(2_000_000),
+            maxFindings: z.number().int().min(1).default(8_000),
+            maxModules: z.number().int().min(1).default(20_000),
+            maxSourceMapSources: z.number().int().min(1).default(5_000),
+            maxParseMilliseconds: z.number().int().min(1).default(30_000),
+        }),
+        run: ({ args, options }) => logCliCommand(logger, CLI_COMMANDS.analyzeJavaScriptApplication, async () => {
+            const context = await electronContext();
+            if (!context.ok)
+                return context.error;
+            const parsed = analyzeJavaScriptApplicationInputSchema.safeParse({
+                input_path: args.path,
+                approved: options.approved,
+                format: options.format,
+                source_map_read_approved: options.sourceMapReadApproved,
+                limits: {
+                    max_entries: options.maxEntries,
+                    max_total_artifact_bytes: options.maxTotalArtifactBytes,
+                    max_artifact_entry_bytes: options.maxArtifactEntryBytes,
+                    max_compression_ratio: options.maxCompressionRatio,
+                    max_depth: options.maxDepth,
+                    max_path_bytes: options.maxPathBytes,
+                    max_text_files: options.maxTextFiles,
+                    max_total_text_bytes: options.maxTotalTextBytes,
+                    max_text_file_bytes: options.maxTextFileBytes,
+                    max_ast_nodes: options.maxAstNodes,
+                    max_findings: options.maxFindings,
+                    max_modules: options.maxModules,
+                    max_source_map_sources: options.maxSourceMapSources,
+                    max_parse_milliseconds: options.maxParseMilliseconds,
+                },
+            });
+            if (!parsed.success)
+                return inputError("analyze_javascript_application");
+            const result = await analyzeJavaScriptApplication(context.authority, parsed.data);
+            return result.ok ? result.value : cliError(result.error);
+        }),
+    });
+};
 const electronContext = async () => {
     const config = parseConfig(process.env);
     if (!config.ok)
@@ -109,6 +212,6 @@ const electronContext = async () => {
 };
 const inputError = (operation) => cliError(new AnalysisInputError(operation));
 const cliError = (error) => ({
-    error: "Electron observation failed",
+    error: "Electron analysis failed",
     ...projectAnalysisError(error),
 });

package/dist/cliEvidenceCommands.js

@@ -2,11 +2,12 @@ import { Cli, z } from "incur";
 import { compareEvidenceBundlesCommand, exportEvidenceBundleCommand, importEvidenceBundleCommand, } from "./application/EvidenceBundleCommands.js";
 import { parseConfig } from "./config.js";
 import { logCliCommand } from "./cliLogging.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
 import { AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "./domain/errors.js";
 import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
 /** Register filesystem-gated Evidence v2 commands. */
 export const registerEvidenceCommands = (cli, logger) => {
-    cli.command("evidence-import", {
+    cli.command(CLI_COMMANDS.evidenceImport, {
         description: "Validate and import a bounded local Evidence v2 bundle",
         args: z.object({
             path: z.string().describe("Evidence bundle JSON path"),
@@ -24,7 +25,7 @@ export const registerEvidenceCommands = (cli, logger) => {
             return imported.ok ? imported.value : cliError(imported.error);
         }),
     });
-    cli.command("evidence-export", {
+    cli.command(CLI_COMMANDS.evidenceExport, {
         description: "Validate and atomically export canonical Evidence v2 JSON",
         args: z.object({
             source: z.string().describe("Existing evidence bundle JSON path"),
@@ -47,7 +48,7 @@ export const registerEvidenceCommands = (cli, logger) => {
             return exported.ok ? exported.value : cliError(exported.error);
         }),
     });
-    cli.command("compare", {
+    cli.command(CLI_COMMANDS.compare, {
         aliases: ["compare-bundles"],
         description: "Compare two canonical Evidence v2 bundles",
         args: z.object({

package/dist/cliInvestigationCommands.js

@@ -5,6 +5,7 @@ import { parseConfig } from "./config.js";
 import { projectAnalysisError } from "./domain/errors.js";
 import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
 import { authorizeFileReadWithDeferredWrite, authorizeRootPermission, } from "./application/DeferredFileAuthorization.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
 const investigationOptionsSchema = z.object({
     yes: z
         .boolean()
@@ -38,7 +39,7 @@ const investigationOptionsSchema = z.object({
 });
 /** Register the persistent cross-version CLI workflow. */
 export const registerInvestigationCommands = (cli, logger) => {
-    cli.command("investigate-versions", {
+    cli.command(CLI_COMMANDS.investigateVersions, {
         description: "Run or resume a persistent cross-version artifact investigation",
         args: z.object({
             leftPath: z.string().describe("Earlier artifact or directory path"),

package/dist/cliJsonInput.js

@@ -0,0 +1,54 @@
+import { readFile, stat } from "node:fs/promises";
+import { AnalysisInputError, projectAnalysisError } from "./domain/errors.js";
+const MAX_JSON_INPUT_BYTES = 64 * 1_024 * 1_024;
+/** Parse bounded inline JSON or one bounded local JSON file for a CLI workflow. */
+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 {
+        const metadata = await stat(value);
+        if (!metadata.isFile())
+            return jsonFileError(value, operation, "not-file");
+        if (metadata.size > MAX_JSON_INPUT_BYTES)
+            return jsonFileError(value, operation, "too-large");
+        const bytes = await readFile(value);
+        if (bytes.byteLength > MAX_JSON_INPUT_BYTES)
+            return jsonFileError(value, operation, "too-large");
+        const parsed = parseJson(bytes.toString("utf8"));
+        return parsed === undefined
+            ? jsonFileError(value, operation, "invalid-json")
+            : { ok: true, value: parsed };
+    }
+    catch {
+        return jsonFileError(value, operation, "read-failed");
+    }
+};
+const parseJson = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+};
+const inputError = (operation) => ({
+    error: "Application workflow failed",
+    ...projectAnalysisError(new AnalysisInputError(operation, undefined, [
+        { path: [], reason: "invalid_format", expected: "JSON" },
+    ])),
+});
+const jsonFileError = (path, operation, reason) => ({
+    ok: false,
+    error: {
+        error: "Application workflow failed",
+        ...projectAnalysisError(new AnalysisInputError(operation, undefined, reason === "invalid-json"
+            ? [{ path: [], reason: "invalid_format", expected: "JSON" }]
+            : [])),
+        input_path: path,
+        input_reason: reason,
+        maximum_input_bytes: MAX_JSON_INPUT_BYTES,
+    },
+});

package/dist/cliPolicyCommands.js

@@ -5,6 +5,7 @@ import { readProjectPermissionStore, revokeProjectPermissionGrant, } from "./app
 import { logCliCommand } from "./cliLogging.js";
 import { parseConfig } from "./config.js";
 import { PermissionRequiredError, projectAnalysisError, } from "./domain/errors.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
 const capabilitySchema = z.enum([
     "process_capture",
     "browser_observe",
@@ -32,7 +33,7 @@ export const approvePolicyRevocation = async (options) => {
 };
 /** Register inspectable, dry-run, and revocation policy UX for the CLI. */
 export const registerPolicyCommands = (cli, logger) => {
-    cli.command("policy", {
+    cli.command(CLI_COMMANDS.policy, {
         description: "Inspect, explain, or revoke unified local permission grants",
         args: z.object({
             action: z.enum(["status", "list", "explain", "revoke"]),

package/dist/cliProcessCommands.js

@@ -1,14 +1,15 @@
 import { Cli, z } from "incur";
 import { captureProcessScenarioFile, compareProcessEvidenceFiles, } from "./application/ProcessCli.js";
 import { logCliCommand } from "./cliLogging.js";
+import { CLI_COMMANDS } from "./cliCommandNames.js";
 /** Register Process Capture v4 one-shot commands through shared application services. */
 export const registerProcessCommands = (cli, logger) => {
-    cli.command("capture-process", {
+    cli.command(CLI_COMMANDS.captureProcess, {
         description: "Capture one approved Process Capture v4 JSON scenario",
         args: z.object({ scenario: z.string().describe("Scenario JSON path") }),
         run: ({ args }) => logCliCommand(logger, "capture-process", () => captureProcessScenarioFile(args.scenario)),
     });
-    cli.command("compare-process-captures", {
+    cli.command(CLI_COMMANDS.compareProcessCaptures, {
         description: "Compare two Process Capture v4 Evidence JSON files",
         args: z.object({
             left: z.string().describe("Left capture Evidence JSON path"),