rea-agents 3.0.0 → 3.2.0

package/dist/cli/managedCommands.js

@@ -1,5 +1,5 @@
 import { z } from "incur";
-import { compareManagedMemberPaths, } from "../application/ManagedMemberComparisonService.js";
+import { compareManagedMemberPaths } from "../application/ManagedMemberComparisonService.js";
 import { verifyManagedNativeBoundariesEvidence } from "../application/ManagedNativeVerificationService.js";
 import { importManagedReconstructionEvidence } from "../application/ManagedReconstructionService.js";
 import { planManagedRuntimeCorrelationEvidence } from "../application/ManagedRuntimeCorrelationService.js";
@@ -11,44 +11,6 @@ import { projectAnalysisError } from "../domain/errors.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { logCliCommand } from "../cliLogging.js";
 import { registerProjectManagedApplicationGraph } from "./managedProjectGraphCommand.js";
-const managedOffset = (subject) => z.number().int().min(0).default(0).describe(`Zero-based ${subject} offset`);
-const managedLimit = (subject, maximum, fallback) => z
-    .number()
-    .int()
-    .min(1)
-    .max(maximum)
-    .default(fallback)
-    .describe(`Maximum ${subject} to return`);
-const managedInspectionLimits = {
-    maxFileBytes: z
-        .number()
-        .int()
-        .min(4_096)
-        .max(1_073_741_824)
-        .default(268_435_456)
-        .describe("Maximum managed artifact file size accepted for inspection"),
-    maxMetadataBytes: z
-        .number()
-        .int()
-        .min(256)
-        .max(268_435_456)
-        .default(67_108_864)
-        .describe("Maximum CLI metadata region size accepted for inspection"),
-    maxTableRows: z
-        .number()
-        .int()
-        .min(1)
-        .max(1_000_000)
-        .default(100_000)
-        .describe("Maximum rows accepted in any CLI metadata table"),
-    maxHeapItemBytes: z
-        .number()
-        .int()
-        .min(1)
-        .max(16_777_216)
-        .default(1_048_576)
-        .describe("Maximum bytes accepted for one CLI metadata heap item"),
-};
 export const registerManagedCommands = (cli, logger) => {
     registerInspectManagedArtifact(cli, logger);
     registerInspectManagedMembers(cli, logger);
@@ -65,39 +27,7 @@ const registerInspectManagedArtifact = (cli, logger) => {
         args: z.object({
             path: z.string().describe("Managed PE executable or assembly path"),
         }),
-        options: z.object({
-            referenceOffset: managedOffset("assembly-reference"),
-            referenceLimit: managedLimit("assembly references", 500, 100),
-            resourceOffset: managedOffset("manifest-resource"),
-            resourceLimit: managedLimit("manifest resources", 500, 100),
-            attributeOffset: managedOffset("assembly-attribute"),
-            attributeLimit: managedLimit("assembly attributes", 500, 100),
-            ...managedInspectionLimits,
-        }),
-        alias: {
-            referenceOffset: "reference-offset",
-            referenceLimit: "reference-limit",
-            resourceOffset: "resource-offset",
-            resourceLimit: "resource-limit",
-            attributeOffset: "attribute-offset",
-            attributeLimit: "attribute-limit",
-            maxFileBytes: "max-file-bytes",
-            maxMetadataBytes: "max-metadata-bytes",
-            maxTableRows: "max-table-rows",
-            maxHeapItemBytes: "max-heap-item-bytes",
-        },
-        run: ({ args, options }) => logCliCommand(logger, "inspect-managed-artifact", () => runProviderAnalysis(args.path, "inspect_managed_artifact", {
-            reference_offset: options.referenceOffset,
-            reference_limit: options.referenceLimit,
-            resource_offset: options.resourceOffset,
-            resource_limit: options.resourceLimit,
-            attribute_offset: options.attributeOffset,
-            attribute_limit: options.attributeLimit,
-            max_file_bytes: options.maxFileBytes,
-            max_metadata_bytes: options.maxMetadataBytes,
-            max_table_rows: options.maxTableRows,
-            max_heap_item_bytes: options.maxHeapItemBytes,
-        }, logger)),
+        run: ({ args }) => logCliCommand(logger, "inspect-managed-artifact", () => runProviderAnalysis(args.path, "inspect_managed_artifact", {}, logger)),
     });
 };
 const registerInspectManagedMembers = (cli, logger) => {
@@ -106,78 +36,7 @@ const registerInspectManagedMembers = (cli, logger) => {
         args: z.object({
             path: z.string().describe("Managed PE executable or assembly path"),
         }),
-        options: z.object({
-            typeOffset: managedOffset("type definition"),
-            typeLimit: managedLimit("type definitions", 500, 100),
-            methodOffset: managedOffset("method definition"),
-            methodLimit: managedLimit("method definitions", 500, 100),
-            fieldOffset: managedOffset("field definition"),
-            fieldLimit: managedLimit("field definitions", 500, 100),
-            memberRefOffset: managedOffset("member reference"),
-            memberRefLimit: managedLimit("member references", 500, 100),
-            edgeOffset: managedOffset("member edge"),
-            edgeLimit: managedLimit("member edges", 1_000, 250),
-            instructionAnchorLimit: z
-                .number()
-                .int()
-                .min(0)
-                .max(500)
-                .default(100)
-                .describe("Maximum CIL instruction anchors per method"),
-            ...managedInspectionLimits,
-            maxMethodBodyBytes: z
-                .number()
-                .int()
-                .min(1)
-                .max(16_777_216)
-                .default(1_048_576)
-                .describe("Maximum CIL method body size accepted for inspection"),
-            maxMethodInstructions: z
-                .number()
-                .int()
-                .min(1)
-                .max(100_000)
-                .default(10_000)
-                .describe("Maximum decoded CIL instructions per method"),
-        }),
-        alias: {
-            typeOffset: "type-offset",
-            typeLimit: "type-limit",
-            methodOffset: "method-offset",
-            methodLimit: "method-limit",
-            fieldOffset: "field-offset",
-            fieldLimit: "field-limit",
-            memberRefOffset: "member-ref-offset",
-            memberRefLimit: "member-ref-limit",
-            edgeOffset: "edge-offset",
-            edgeLimit: "edge-limit",
-            instructionAnchorLimit: "instruction-anchor-limit",
-            maxFileBytes: "max-file-bytes",
-            maxMetadataBytes: "max-metadata-bytes",
-            maxTableRows: "max-table-rows",
-            maxHeapItemBytes: "max-heap-item-bytes",
-            maxMethodBodyBytes: "max-method-body-bytes",
-            maxMethodInstructions: "max-method-instructions",
-        },
-        run: ({ args, options }) => logCliCommand(logger, "inspect-managed-members", () => runProviderAnalysis(args.path, "inspect_managed_members", {
-            type_offset: options.typeOffset,
-            type_limit: options.typeLimit,
-            method_offset: options.methodOffset,
-            method_limit: options.methodLimit,
-            field_offset: options.fieldOffset,
-            field_limit: options.fieldLimit,
-            member_ref_offset: options.memberRefOffset,
-            member_ref_limit: options.memberRefLimit,
-            edge_offset: options.edgeOffset,
-            edge_limit: options.edgeLimit,
-            instruction_anchor_limit: options.instructionAnchorLimit,
-            max_file_bytes: options.maxFileBytes,
-            max_metadata_bytes: options.maxMetadataBytes,
-            max_table_rows: options.maxTableRows,
-            max_heap_item_bytes: options.maxHeapItemBytes,
-            max_method_body_bytes: options.maxMethodBodyBytes,
-            max_method_instructions: options.maxMethodInstructions,
-        }, logger)),
+        run: ({ args }) => logCliCommand(logger, "inspect-managed-members", () => runProviderAnalysis(args.path, "inspect_managed_members", {}, logger)),
     });
 };
 const registerInspectManagedNativeBoundaries = (cli, logger) => {
@@ -186,39 +45,7 @@ const registerInspectManagedNativeBoundaries = (cli, logger) => {
         args: z.object({
             path: z.string().describe("Managed PE executable or assembly path"),
         }),
-        options: z.object({
-            moduleRefOffset: managedOffset("module reference"),
-            moduleRefLimit: managedLimit("module references", 500, 100),
-            importOffset: managedOffset("platform import"),
-            importLimit: managedLimit("platform imports", 500, 100),
-            implementationOffset: managedOffset("native implementation"),
-            implementationLimit: managedLimit("native implementations", 500, 100),
-            ...managedInspectionLimits,
-        }),
-        alias: {
-            moduleRefOffset: "module-ref-offset",
-            moduleRefLimit: "module-ref-limit",
-            importOffset: "import-offset",
-            importLimit: "import-limit",
-            implementationOffset: "implementation-offset",
-            implementationLimit: "implementation-limit",
-            maxFileBytes: "max-file-bytes",
-            maxMetadataBytes: "max-metadata-bytes",
-            maxTableRows: "max-table-rows",
-            maxHeapItemBytes: "max-heap-item-bytes",
-        },
-        run: ({ args, options }) => logCliCommand(logger, "inspect-managed-native-boundaries", () => runProviderAnalysis(args.path, "inspect_managed_native_boundaries", {
-            module_ref_offset: options.moduleRefOffset,
-            module_ref_limit: options.moduleRefLimit,
-            import_offset: options.importOffset,
-            import_limit: options.importLimit,
-            implementation_offset: options.implementationOffset,
-            implementation_limit: options.implementationLimit,
-            max_file_bytes: options.maxFileBytes,
-            max_metadata_bytes: options.maxMetadataBytes,
-            max_table_rows: options.maxTableRows,
-            max_heap_item_bytes: options.maxHeapItemBytes,
-        }, logger)),
+        run: ({ args }) => logCliCommand(logger, "inspect-managed-native-boundaries", () => runProviderAnalysis(args.path, "inspect_managed_native_boundaries", {}, logger)),
     });
 };
 const compareManagedMemberArgs = z.object({
@@ -229,83 +56,10 @@ const registerCompareManagedMembers = (cli, logger) => {
     cli.command(CLI_COMMANDS.compareManagedMembers, {
         description: "Compare two managed PE/CLI member inventories without name-based matching",
         args: compareManagedMemberArgs,
-        options: z.object({
-            maxMethodMatches: z
-                .number()
-                .int()
-                .min(1)
-                .max(50_000)
-                .default(10_000)
-                .describe("Maximum exact method matches to return"),
-            maxFieldMatches: z
-                .number()
-                .int()
-                .min(0)
-                .max(50_000)
-                .default(5_000)
-                .describe("Maximum exact field matches to return"),
-            maxCandidates: z
-                .number()
-                .int()
-                .min(1)
-                .max(500)
-                .default(50)
-                .describe("Maximum ambiguous candidates per unmatched member"),
-            typeLimit: managedLimit("type definitions per artifact", 500, 500),
-            methodLimit: managedLimit("method definitions per artifact", 500, 500),
-            fieldLimit: managedLimit("field definitions per artifact", 500, 500),
-            memberRefLimit: managedLimit("member references per artifact", 500, 500),
-            edgeLimit: managedLimit("member edges per artifact", 1_000, 1_000),
-            instructionAnchorLimit: z
-                .number()
-                .int()
-                .min(0)
-                .max(500)
-                .default(500)
-                .describe("Maximum CIL instruction anchors per compared method"),
-            ...managedInspectionLimits,
-            maxMethodBodyBytes: z
-                .number()
-                .int()
-                .min(1)
-                .max(16_777_216)
-                .default(1_048_576)
-                .describe("Maximum CIL method body size accepted for comparison"),
-            maxMethodInstructions: z
-                .number()
-                .int()
-                .min(1)
-                .max(100_000)
-                .default(100_000)
-                .describe("Maximum decoded CIL instructions per compared method"),
-        }),
-        alias: {
-            maxMethodMatches: "max-method-matches",
-            maxFieldMatches: "max-field-matches",
-            maxCandidates: "max-candidates",
-            typeLimit: "type-limit",
-            methodLimit: "method-limit",
-            fieldLimit: "field-limit",
-            memberRefLimit: "member-ref-limit",
-            edgeLimit: "edge-limit",
-            instructionAnchorLimit: "instruction-anchor-limit",
-            maxFileBytes: "max-file-bytes",
-            maxMetadataBytes: "max-metadata-bytes",
-            maxTableRows: "max-table-rows",
-            maxHeapItemBytes: "max-heap-item-bytes",
-            maxMethodBodyBytes: "max-method-body-bytes",
-            maxMethodInstructions: "max-method-instructions",
-        },
-        run: ({ args, options }) => logCliCommand(logger, "compare-managed-members", async () => {
+        run: ({ args }) => logCliCommand(logger, "compare-managed-members", async () => {
             const result = await compareManagedMemberPaths({
                 leftPath: args.leftPath,
                 rightPath: args.rightPath,
-                comparisonLimits: {
-                    max_method_matches: options.maxMethodMatches,
-                    max_field_matches: options.maxFieldMatches,
-                    max_candidates: options.maxCandidates,
-                },
-                memberLimits: buildMemberLimits(options),
             });
             return result.ok
                 ? result.value
@@ -316,25 +70,6 @@ const registerCompareManagedMembers = (cli, logger) => {
         }),
     });
 };
-const buildMemberLimits = (options) => ({
-    maxFileBytes: options.maxFileBytes,
-    typeOffset: 0,
-    typeLimit: options.typeLimit,
-    methodOffset: 0,
-    methodLimit: options.methodLimit,
-    fieldOffset: 0,
-    fieldLimit: options.fieldLimit,
-    memberRefOffset: 0,
-    memberRefLimit: options.memberRefLimit,
-    edgeOffset: 0,
-    edgeLimit: options.edgeLimit,
-    instructionAnchorLimit: options.instructionAnchorLimit,
-    maxMetadataBytes: options.maxMetadataBytes,
-    maxTableRows: options.maxTableRows,
-    maxHeapItemBytes: options.maxHeapItemBytes,
-    maxMethodBodyBytes: options.maxMethodBodyBytes,
-    maxMethodInstructions: options.maxMethodInstructions,
-});
 const registerImportManagedReconstruction = (cli, logger) => {
     cli.command(CLI_COMMANDS.importManagedReconstruction, {
         description: "Import decompiler-produced managed reconstruction against exact static member evidence",
@@ -388,7 +123,7 @@ const registerPlanManagedRuntimeCorrelation = (cli, logger) => {
             if (!authority.ok)
                 return projectAnalysisError(authority.error);
             const result = await planManagedRuntimeCorrelationEvidence({
-                policy: config.value.managedRuntimePolicy,
+                policy: () => config.value.managedRuntimePolicy,
                 authority: authority.value,
             }, input.value);
             return result.ok ? result.value : projectAnalysisError(result.error);

package/dist/cli/setupCommands.js

@@ -3,13 +3,12 @@ import { DOCTOR_PROVIDER_IDS, runDoctor, } from "../application/Doctor.js";
 import { runSetup, systemSetupHost, } from "../application/Setup.js";
 import { runUninstall } from "../application/Uninstall.js";
 import { runUpgrade, systemUpgradeHost } from "../application/Upgrade.js";
-import { conciseSetupResult, confirmInteractiveSetup, renderInteractiveSetupResult, renderSetupProgress, } from "../cliSetup.js";
+import { confirmInteractiveSetup, renderInteractiveSetupResult, renderSetupProgress, } from "../cliSetup.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { logCliCommand } from "../cliLogging.js";
 import { createSystemDoctorHost } from "../doctorRuntime.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
 import { SUPPORTED_CLIENT_DEFINITIONS } from "../application/SupportedClients.js";
-import { projectDoctorReport } from "../application/DoctorProjection.js";
 const supportedClientIds = SUPPORTED_CLIENT_DEFINITIONS.map(({ name }) => name);
 const supportedClientSchema = z
     .string()
@@ -53,10 +52,6 @@ const registerSetupCommand = (cli, logger) => {
                 .boolean()
                 .default(false)
                 .describe("Use sequential accessible setup prompts"),
-            detail: z
-                .enum(["summary", "full"])
-                .default("summary")
-                .describe("Summary or complete setup and doctor diagnostics"),
         }),
         alias: { yes: "y" },
         run: ({ options, formatExplicit }) => logCliCommand(logger, "setup", () => runSetupCommand({ options, formatExplicit })),
@@ -79,12 +74,8 @@ const registerDoctorCommand = (cli, logger) => {
                 .boolean()
                 .optional()
                 .describe("Require the installed REA skill identity to be aligned"),
-            detail: z
-                .enum(["summary", "full"])
-                .default("summary")
-                .describe("Summary or complete doctor diagnostics"),
         }),
-        run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target, createSystemDoctorHost(), doctorScope(options)).then((report) => projectDoctorReport(report, options.detail))),
+        run: ({ options }) => logCliCommand(logger, "doctor", () => runDoctor(options.target, createSystemDoctorHost(), doctorScope(options))),
     });
 };
 const registerMaintenanceCommands = (cli, logger) => {
@@ -115,7 +106,7 @@ const runSetupCommand = async (input) => {
         : undefined);
     if (interactive)
         renderInteractiveSetupResult(result);
-    return options.detail === "full" ? result : conciseSetupResult(result);
+    return result;
 };
 const setupRunOptions = (input, interactive, hasExplicitScope) => {
     const { options } = input;

package/dist/cli/utilityCommands.js

@@ -2,9 +2,8 @@ import { z } from "incur";
 import { runCapabilityStatus, runProviderAnalysis, runProviderStatus, } from "../application/DirectAnalysis.js";
 import { importReferenceSource } from "../application/ReferenceSourceImport.js";
 import { projectReferenceSourceImportError } from "../application/ReferenceSourceImportTypes.js";
-import { loadConfiguredPermissionAuthority } from "../application/PermissionConfiguration.js";
 import { parseConfig } from "../config.js";
-import { AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "../domain/errors.js";
+import { projectAnalysisError } from "../domain/errors.js";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { logCliCommand } from "../cliLogging.js";
 import { CLI_COMMANDS } from "../cliCommandNames.js";
@@ -22,15 +21,9 @@ const registerCapabilityCommands = (cli, logger) => {
             description: command === "capabilities"
                 ? "List provider capabilities and side effects"
                 : "List configured analysis providers",
-            options: z.object({
-                detail: z
-                    .enum(["summary", "full"])
-                    .default("summary")
-                    .describe("Summary or complete provider descriptors"),
-            }),
-            run: ({ options }) => logCliCommand(logger, command, () => command === CLI_COMMANDS.providers
-                ? runProviderStatus(logger, options.detail)
-                : runCapabilityStatus(logger, options.detail)),
+            run: () => logCliCommand(logger, command, () => command === CLI_COMMANDS.providers
+                ? runProviderStatus(logger)
+                : runCapabilityStatus(logger)),
         });
     }
 };
@@ -59,13 +52,12 @@ const registerNativeCommands = (cli, logger) => {
         run: ({ args, options }) => logCliCommand(logger, "inspect-plist", () => runProviderAnalysis(args.path, "inspect_plist", { relative_path: options.relativePath }, logger)),
     });
     cli.command(CLI_COMMANDS.demangleSwift, {
-        description: "Demangle a bounded Swift symbol batch without Hopper",
+        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)
-                .max(500)
                 .describe("Swift mangled symbols to demangle"),
         }),
         run: ({ args }) => logCliCommand(logger, "demangle-swift", () => runProviderAnalysis(args.path, "demangle_swift", { symbols: args.symbols }, logger)),
@@ -73,11 +65,11 @@ const registerNativeCommands = (cli, logger) => {
 };
 const registerReferenceSourceCommand = (cli, logger) => {
     cli.command(CLI_COMMANDS.importReferenceSource, {
-        description: "Import a bounded source tree as historical reference only",
+        description: "Import a source tree as historical reference only",
         args: z.object({
             root: z
                 .string()
-                .describe("Source root allowed by REA_REFERENCE_ROOTS_JSON"),
+                .describe("Local source directory to import as historical reference"),
         }),
         run: ({ args }) => logCliCommand(logger, "import-reference-source", async () => {
             const config = parseConfig(process.env);
@@ -86,32 +78,6 @@ const registerReferenceSourceCommand = (cli, logger) => {
                     error: "Import failed",
                     ...projectAnalysisError(config.error),
                 };
-            const authority = await loadConfiguredPermissionAuthority(config.value);
-            if (!authority.ok)
-                return {
-                    error: "Import failed",
-                    ...projectAnalysisError(authority.error),
-                };
-            const authorized = await authority.value.authorize({
-                capability: "reference_read",
-                roots: [args.root],
-                executables: [],
-                environment_names: [],
-                network: "none",
-                mount: false,
-                operation_identity: `import_reference_source:${args.root}`,
-            }, "read");
-            if (!authorized.ok) {
-                const error = authorized.error instanceof PermissionRequiredError
-                    ? authorized.error
-                    : new AnalysisProtocolError(authorized.error.message, {
-                        cause: authorized.error,
-                    });
-                return {
-                    error: "Import failed",
-                    ...projectAnalysisError(error),
-                };
-            }
             const imported = await importReferenceSource({
                 root: args.root,
                 caller: "rea-cli",

package/dist/cli.js

@@ -7,7 +7,6 @@ import { registerCoreAnalysisCommands } from "./cli/coreAnalysisCommands.js";
 import { registerUtilityCommands } from "./cli/utilityCommands.js";
 import { registerArtifactCommands } from "./cli/artifactCommands.js";
 import { registerManagedCommands } from "./cli/managedCommands.js";
-import { registerInvestigationCommands } from "./cliInvestigationCommands.js";
 import { registerEvidenceCommands } from "./cliEvidenceCommands.js";
 import { registerProcessCommands } from "./cliProcessCommands.js";
 import { registerPolicyCommands } from "./cliPolicyCommands.js";
@@ -48,7 +47,6 @@ export const createCli = () => {
     registerUtilityCommands(cli, logger);
     registerArtifactCommands(cli, logger);
     registerManagedCommands(cli, logger);
-    registerInvestigationCommands(cli, logger);
     registerEvidenceCommands(cli, logger);
     registerProcessCommands(cli, logger);
     registerPolicyCommands(cli, logger);