rea-agents 1.3.0 → 1.4.0

package/dist/cli.js

@@ -14,8 +14,10 @@ import { importReferenceSource } from "./application/ReferenceSourceImport.js";
 import { registerEvidenceCommands } from "./cliEvidenceCommands.js";
 import { registerProcessCommands } from "./cliProcessCommands.js";
 import { registerInvestigationCommands } from "./cliInvestigationCommands.js";
-import { projectAnalysisError } from "./domain/errors.js";
+import { AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "./domain/errors.js";
 import { projectReferenceSourceImportError } from "./application/ReferenceSourceImportTypes.js";
+import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
+import { registerPolicyCommands } from "./cliPolicyCommands.js";
 /**
  * Build the one-shot Incur CLI without starting Hopper at import time.
  * Analysis commands acquire and close their own sessions; bare `mcp` and
@@ -26,7 +28,7 @@ export const createCli = () => {
         ? "silent"
         : parseLogLevel(process.env.REA_LOG_LEVEL));
     const cli = Cli.create(PRODUCT_IDENTITY.cliBinary, {
-        version: process.env.REA_PACKAGE_VERSION ?? "0.0.0-development",
+        version: PRODUCT_IDENTITY.packageVersion,
         description: "Reverse engineer anything from your terminal or agent.",
         mcp: {
             command: PRODUCT_IDENTITY.mcpCommand,
@@ -55,6 +57,7 @@ export const createCli = () => {
     registerEvidenceCommands(cli, logger);
     registerReferenceSourceCommand(cli, logger);
     registerProcessCommands(cli, logger);
+    registerPolicyCommands(cli, logger);
     return cli;
 };
 const registerCoreCommands = (cli, logger) => {
@@ -135,7 +138,7 @@ const registerSetupCommands = (cli, logger) => {
     });
     cli.command("upgrade", {
         description: "Upgrade a global npm installation to the latest REA release",
-        run: ({ formatExplicit }) => logCliCommand(logger, "upgrade", () => runUpgrade(process.env.REA_PACKAGE_VERSION ?? "0.0.0-development", systemUpgradeHost(), formatExplicit ? "structured" : "human")),
+        run: ({ formatExplicit }) => logCliCommand(logger, "upgrade", () => runUpgrade(PRODUCT_IDENTITY.packageVersion, systemUpgradeHost(), formatExplicit ? "structured" : "human")),
     });
 };
 const confirmSetup = async (actions) => {
@@ -270,6 +273,32 @@ 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",
@@ -295,7 +324,17 @@ const registerArtifactCommands = (cli, logger) => {
         options: z.object({
             offset: z.number().int().min(0).default(0),
             limit: z.number().int().min(1).max(500).default(100),
+            integrityPolicy: z.enum(["fail", "record-and-continue"]).default("fail"),
+            integrityContinueApproved: z.boolean().default(false),
+            maxIntegrityMismatches: z.number().int().min(1).max(100).default(10),
+            nativeMountApproved: z.boolean().default(false),
         }),
+        alias: {
+            integrityPolicy: "integrity-policy",
+            integrityContinueApproved: "integrity-continue-approved",
+            maxIntegrityMismatches: "max-integrity-mismatches",
+            nativeMountApproved: "native-mount-approved",
+        },
         run: ({ args, options }) => logCliCommand(logger, "inventory-artifact", () => runProviderAnalysis(args.path, "inventory_artifact", {
             node_offset: options.offset,
             node_limit: options.limit,
@@ -303,6 +342,10 @@ const registerArtifactCommands = (cli, logger) => {
             occurrence_limit: options.limit,
             edge_offset: options.offset,
             edge_limit: options.limit,
+            integrity_policy: options.integrityPolicy,
+            integrity_continue_approved: options.integrityContinueApproved,
+            max_integrity_mismatches: options.maxIntegrityMismatches,
+            native_mount_approved: options.nativeMountApproved,
         }, logger)),
     });
     cli.command("extract-artifact", {

package/dist/cliEvidenceCommands.js

@@ -2,7 +2,8 @@ import { Cli, z } from "incur";
 import { compareEvidenceBundlesCommand, exportEvidenceBundleCommand, importEvidenceBundleCommand, } from "./application/EvidenceBundleCommands.js";
 import { parseConfig } from "./config.js";
 import { logCliCommand } from "./cliLogging.js";
-import { projectAnalysisError } from "./domain/errors.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", {
@@ -14,6 +15,11 @@ export const registerEvidenceCommands = (cli, logger) => {
             const config = parseConfig(process.env);
             if (!config.ok)
                 return cliError(config.error);
+            const denied = await authorizeEvidence(config.value, [
+                { capability: "evidence_read", path: args.path, access: "read" },
+            ]);
+            if (denied !== undefined)
+                return cliError(denied);
             const imported = await importEvidenceBundleCommand(args.path, config.value.evidenceFilePolicy);
             return imported.ok ? imported.value : cliError(imported.error);
         }),
@@ -31,6 +37,12 @@ export const registerEvidenceCommands = (cli, logger) => {
             const config = parseConfig(process.env);
             if (!config.ok)
                 return cliError(config.error);
+            const denied = await authorizeEvidence(config.value, [
+                { capability: "evidence_read", path: args.source, access: "read" },
+                { capability: "evidence_write", path: args.output, access: "write" },
+            ]);
+            if (denied !== undefined)
+                return cliError(denied);
             const exported = await exportEvidenceBundleCommand(args.source, args.output, options.overwrite, config.value.evidenceFilePolicy);
             return exported.ok ? exported.value : cliError(exported.error);
         }),
@@ -50,6 +62,12 @@ export const registerEvidenceCommands = (cli, logger) => {
             const config = parseConfig(process.env);
             if (!config.ok)
                 return cliError(config.error);
+            const denied = await authorizeEvidence(config.value, [
+                { capability: "evidence_read", path: args.left, access: "read" },
+                { capability: "evidence_read", path: args.right, access: "read" },
+            ]);
+            if (denied !== undefined)
+                return cliError(denied);
             const compared = await compareEvidenceBundlesCommand({
                 leftPath: args.left,
                 rightPath: args.right,
@@ -61,6 +79,29 @@ export const registerEvidenceCommands = (cli, logger) => {
         }),
     });
 };
+const authorizeEvidence = async (config, requests) => {
+    const authority = await loadConfiguredPermissionAuthority(config);
+    if (!authority.ok)
+        return authority.error;
+    for (const request of requests) {
+        const result = await authority.value.authorize({
+            capability: request.capability,
+            roots: [request.path],
+            executables: [],
+            environment_names: [],
+            network: "none",
+            mount: false,
+            operation_identity: `cli:${request.capability}:${request.path}`,
+        }, request.access);
+        if (!result.ok)
+            return result.error instanceof PermissionRequiredError
+                ? result.error
+                : new AnalysisProtocolError(result.error.message, {
+                    cause: result.error,
+                });
+    }
+    return undefined;
+};
 const cliError = (error) => ({
     error: "Analysis failed",
     ...projectAnalysisError(error),

package/dist/cliInvestigationCommands.js

@@ -2,6 +2,8 @@ import { Cli, z } from "incur";
 import { runCrossVersionInvestigation } from "./application/CrossVersionInvestigation.js";
 import { logCliCommand } from "./cliLogging.js";
 import { parseConfig } from "./config.js";
+import { AnalysisProtocolError, PermissionRequiredError, projectAnalysisError, } from "./domain/errors.js";
+import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
 const investigationOptionsSchema = z.object({
     yes: z
         .boolean()
@@ -24,6 +26,9 @@ const investigationOptionsSchema = z.object({
         .default(268_435_456),
     pageSize: z.number().int().min(1).max(500).default(500),
     changeLimit: z.number().int().min(1).max(500).default(500),
+    integrityPolicy: z.enum(["fail", "record-and-continue"]).default("fail"),
+    integrityContinueApproved: z.boolean().default(false),
+    maxIntegrityMismatches: z.number().int().min(1).max(100).default(10),
 });
 /** Register the persistent cross-version CLI workflow. */
 export const registerInvestigationCommands = (cli, logger) => {
@@ -43,6 +48,9 @@ export const registerInvestigationCommands = (cli, logger) => {
             maxEntryBytes: "max-entry-bytes",
             pageSize: "page-size",
             changeLimit: "change-limit",
+            integrityPolicy: "integrity-policy",
+            integrityContinueApproved: "integrity-continue-approved",
+            maxIntegrityMismatches: "max-integrity-mismatches",
             yes: "y",
         },
         run: ({ args, options }) => logCliCommand(logger, "investigate-versions", () => runInvestigation(args, options)),
@@ -56,7 +64,43 @@ const runInvestigation = async (args, options) => {
         };
     const config = parseConfig(process.env);
     if (!config.ok)
-        return { error: config.error._tag, message: config.error.message };
+        return cliError(config.error);
+    const authority = await loadConfiguredPermissionAuthority(config.value);
+    if (!authority.ok)
+        return cliError(authority.error);
+    for (const scope of [
+        {
+            capability: "investigation_workspace_read",
+            roots: [args.workspacePath],
+            access: "write",
+        },
+        {
+            capability: "investigation_workspace_write",
+            roots: [args.workspacePath],
+            access: "write",
+        },
+        {
+            capability: "investigation_input",
+            roots: [args.leftPath, args.rightPath],
+            access: "read",
+        },
+    ]) {
+        const authorized = await authority.value.authorize({
+            capability: scope.capability,
+            roots: scope.roots,
+            executables: [],
+            environment_names: [],
+            network: "none",
+            mount: false,
+            operation_identity: `investigate_versions:${scope.capability}:${scope.roots.join(":")}`,
+        }, scope.access);
+        if (!authorized.ok)
+            return cliError(authorized.error instanceof PermissionRequiredError
+                ? authorized.error
+                : new AnalysisProtocolError(authorized.error.message, {
+                    cause: authorized.error,
+                }));
+    }
     const investigated = await runCrossVersionInvestigation({
         approved: true,
         workspace_path: args.workspacePath,
@@ -66,6 +110,9 @@ const runInvestigation = async (args, options) => {
             : { expected_workspace_revision: options.expectedRevision }),
         left_path: args.leftPath,
         right_path: args.rightPath,
+        integrity_policy: options.integrityPolicy,
+        integrity_continue_approved: options.integrityContinueApproved,
+        max_integrity_mismatches: options.maxIntegrityMismatches,
         options: {
             max_entries: options.maxEntries,
             max_total_bytes: options.maxTotalBytes,
@@ -76,11 +123,15 @@ const runInvestigation = async (args, options) => {
             page_size: options.pageSize,
             change_limit: options.changeLimit,
         },
-    }, config.value.evidenceFilePolicy, { inputRoots: config.value.investigationInputRoots });
+    }, config.value.evidenceFilePolicy, {
+        inputRoots: config.value.investigationInputRoots,
+        integrityContinueEnabled: config.value.artifactIntegrityContinueEnabled,
+    });
     return investigated.ok
         ? investigated.value.evidence
-        : {
-            error: investigated.error._tag,
-            message: investigated.error.message,
-        };
+        : cliError(investigated.error);
 };
+const cliError = (error) => ({
+    error: "Analysis failed",
+    ...projectAnalysisError(error),
+});

package/dist/cliLogging.js

@@ -1,13 +1,30 @@
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Identify caller-visible CLI outcomes that mean the requested operation failed. */
+export const isCliOperationFailure = (value) => {
+    if (!isRecord(value))
+        return false;
+    if (typeof value.error === "string")
+        return true;
+    if (value.healthy === false)
+        return true;
+    return (value.status === "failed" ||
+        value.status === "needs_confirmation" ||
+        value.status === "needs_human" ||
+        value.status === "planned");
+};
 /** Log one CLI command with duration and a stable success or failure status. */
 export const logCliCommand = async (logger, command, execute) => {
     const startedAt = performance.now();
     try {
         const value = await execute();
-        logger.info({
+        const failed = isCliOperationFailure(value);
+        logger[failed ? "error" : "info"]({
             command,
             durationMs: Math.round((performance.now() - startedAt) * 100) / 100,
-            status: "ok",
-        }, "CLI command completed");
+            status: failed ? "error" : "ok",
+        }, failed ? "CLI command failed" : "CLI command completed");
+        if (failed)
+            process.exitCode = 1;
         return value;
     }
     catch (cause) {

package/dist/cliPolicyCommands.js

@@ -0,0 +1,115 @@
+import { Cli, z } from "incur";
+import { loadConfiguredPermissionAuthority } from "./application/PermissionConfiguration.js";
+import { readProjectPermissionStore, writeProjectPermissionStore, } from "./application/ProjectPermissionStore.js";
+import { logCliCommand } from "./cliLogging.js";
+import { parseConfig } from "./config.js";
+import { PermissionRequiredError, projectAnalysisError, } from "./domain/errors.js";
+const capabilitySchema = z.enum([
+    "process_capture",
+    "evidence_read",
+    "evidence_write",
+    "investigation_input",
+    "investigation_workspace_read",
+    "investigation_workspace_write",
+    "snapshot_read",
+    "snapshot_write",
+    "artifact_extract",
+    "native_mount",
+    "reference_read",
+]);
+/** Register inspectable, dry-run, and revocation policy UX for the CLI. */
+export const registerPolicyCommands = (cli, logger) => {
+    cli.command("policy", {
+        description: "Inspect, explain, or revoke unified local permission grants",
+        args: z.object({
+            action: z.enum(["status", "list", "explain", "revoke"]),
+            value: z.string().optional(),
+        }),
+        options: z.object({
+            root: z.string().optional(),
+            executable: z.string().optional(),
+            environmentNames: z.array(z.string()).default([]),
+            network: z.enum(["none", "loopback", "external"]).default("none"),
+            mount: z.boolean().default(false),
+            write: z.boolean().default(false),
+        }),
+        alias: { environmentNames: "environment-names" },
+        run: ({ args, options }) => logCliCommand(logger, "policy", async () => {
+            const config = parseConfig(process.env);
+            if (!config.ok)
+                return failure(config.error);
+            if (args.action === "status")
+                return {
+                    reload: "SIGHUP",
+                    restart_required: false,
+                    administrator_ceilings: config.value.permissionCeilings,
+                    project_store: config.value.permissionProjectStore ?? null,
+                };
+            if (args.action === "list")
+                return readProjectGrants(config.value).then((result) => result.ok ? { grants: result.grants } : result.error);
+            if (args.action === "revoke") {
+                if (args.value === undefined)
+                    return { error: "Grant ID is required for policy revoke" };
+                const result = await readProjectGrants(config.value);
+                if (!result.ok)
+                    return result.error;
+                const retained = result.grants.filter(({ grant_id }) => grant_id !== args.value);
+                if (retained.length === result.grants.length)
+                    return { error: "Grant was not found", grant_id: args.value };
+                const written = await writeProjectPermissionStore(result.path, result.root, retained);
+                return written.ok
+                    ? {
+                        revoked: args.value,
+                        reload: "Send SIGHUP to the REA MCP process",
+                    }
+                    : { error: written.error.message };
+            }
+            const capability = capabilitySchema.safeParse(args.value);
+            if (!capability.success)
+                return {
+                    error: "A registered capability is required for policy explain",
+                };
+            return explain(config.value, capability.data, options);
+        }),
+    });
+};
+const explain = async (config, capability, options) => {
+    const authority = await loadConfiguredPermissionAuthority(config);
+    if (!authority.ok)
+        return failure(authority.error);
+    const evaluated = await authority.value.explain({
+        capability,
+        roots: options.root === undefined ? [] : [options.root],
+        executables: options.executable === undefined ? [] : [options.executable],
+        environment_names: options.environmentNames,
+        network: options.network,
+        mount: options.mount,
+        operation_identity: `policy_explain:${capability}`,
+    }, options.write ? "write" : "read");
+    return evaluated.ok
+        ? { allowed: true, grant_id: evaluated.value.grant_id }
+        : evaluated.error instanceof PermissionRequiredError
+            ? { allowed: false, error: projectAnalysisError(evaluated.error) }
+            : { allowed: false, error: evaluated.error.message };
+};
+const readProjectGrants = async (config) => {
+    if (config.permissionProjectRoot === undefined ||
+        config.permissionProjectStore === undefined)
+        return {
+            ok: false,
+            error: { error: "Project policy is not configured" },
+        };
+    const store = await readProjectPermissionStore(config.permissionProjectStore, config.permissionProjectRoot);
+    return store.ok
+        ? {
+            ok: true,
+            grants: store.value?.grants ?? [],
+            path: config.permissionProjectStore,
+            root: config.permissionProjectRoot,
+        }
+        : { ok: false, error: { error: store.error.message } };
+};
+const failure = (error) => ({
+    error: "Policy command failed",
+    ...projectAnalysisError(error),
+});

package/dist/cliProcessCommands.js

@@ -1,22 +1,12 @@
-import { Cli, Errors, z } from "incur";
-import { captureProcessScenarioFile, compareProcessEvidenceFiles, isProcessCliErrorOutput, } from "./application/ProcessCli.js";
+import { Cli, z } from "incur";
+import { captureProcessScenarioFile, compareProcessEvidenceFiles, } from "./application/ProcessCli.js";
 import { logCliCommand } from "./cliLogging.js";
-const requireProcessCommandSuccess = async (execute) => {
-    const value = await execute();
-    if (isProcessCliErrorOutput(value))
-        throw new Errors.IncurError({
-            code: "PROCESS_COMMAND_FAILED",
-            message: value.message,
-            retryable: false,
-        });
-    return value;
-};
 /** Register Process Capture v4 one-shot commands through shared application services. */
 export const registerProcessCommands = (cli, logger) => {
     cli.command("capture-process", {
         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", () => requireProcessCommandSuccess(() => captureProcessScenarioFile(args.scenario))),
+        run: ({ args }) => logCliCommand(logger, "capture-process", () => captureProcessScenarioFile(args.scenario)),
     });
     cli.command("compare-process-captures", {
         description: "Compare two Process Capture v4 Evidence JSON files",
@@ -24,6 +14,6 @@ export const registerProcessCommands = (cli, logger) => {
             left: z.string().describe("Left capture Evidence JSON path"),
             right: z.string().describe("Right capture Evidence JSON path"),
         }),
-        run: ({ args }) => logCliCommand(logger, "compare-process-captures", () => requireProcessCommandSuccess(() => compareProcessEvidenceFiles(args.left, args.right))),
+        run: ({ args }) => logCliCommand(logger, "compare-process-captures", () => compareProcessEvidenceFiles(args.left, args.right)),
     });
 };

package/dist/config.js

@@ -5,16 +5,24 @@ const DEFAULT_HOPPER_LAUNCHER_PATH = "/Applications/Hopper Disassembler.app/Cont
 const defaultHopperLauncherPath = () => process.platform === "linux"
     ? "/opt/hopper/bin/Hopper"
     : DEFAULT_HOPPER_LAUNCHER_PATH;
-const environmentSchema = z.object({
+const environmentSchema = z
+    .object({
     HOPPER_LAUNCHER_PATH: z.string().min(1).optional(),
     HOPPER_TARGET_PATH: z.string().min(1).optional(),
-    HOPPER_TARGET_KIND: z.enum(["executable", "database"]).default("executable"),
+    HOPPER_TARGET_KIND: z
+        .enum(["executable", "database"])
+        .default("executable"),
     HOPPER_LOADER_ARGS_JSON: z.string().optional(),
     REA_LOG_LEVEL: z
         .enum(["trace", "debug", "info", "warn", "error", "fatal", "silent"])
         .default("info"),
     REA_PROCESS_CAPTURE_ENABLED: z.enum(["true", "false"]).default("false"),
-    REA_ARTIFACT_NATIVE_MOUNT_ENABLED: z.enum(["true", "false"]).default("false"),
+    REA_ARTIFACT_NATIVE_MOUNT_ENABLED: z
+        .enum(["true", "false"])
+        .default("false"),
+    REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED: z
+        .enum(["true", "false"])
+        .default("false"),
     REA_PROCESS_ALLOW_EXTERNAL_NETWORK: z
         .enum(["true", "false"])
         .default("false"),
@@ -26,6 +34,12 @@ const environmentSchema = z.object({
     REA_ANALYSIS_SNAPSHOT_ROOTS_JSON: z.string().default("[]"),
     REA_REFERENCE_ROOTS_JSON: z.string().default("[]"),
     REA_REFERENCE_SECRET_PATTERNS_JSON: z.string().default("[]"),
+    REA_PERMISSION_PROJECT_ROOT: z.string().min(1).optional(),
+    REA_PERMISSION_PROJECT_STORE: z.string().min(1).optional(),
+})
+    .refine((value) => (value.REA_PERMISSION_PROJECT_ROOT === undefined) ===
+    (value.REA_PERMISSION_PROJECT_STORE === undefined), {
+    message: "REA_PERMISSION_PROJECT_ROOT and REA_PERMISSION_PROJECT_STORE must be configured together",
 });
 const parseStringArray = (encoded, name) => {
     try {
@@ -50,6 +64,21 @@ const filePolicy = (roots) => ({
     maxStringLength: 1024 * 1024,
     maxNodes: 1_000_000,
 });
+const permissionScope = (capability, roots, options = {}) => ({
+    capability,
+    roots,
+    executables: options.executables ?? [],
+    environment_names: options.environment_names ?? [],
+    network: options.network ?? "none",
+    mount: options.mount ?? false,
+});
+const administratorGrants = (ceilings) => ceilings.map((ceiling) => ({
+    ...ceiling,
+    grant_id: `administrator:${ceiling.capability}`,
+    lifetime: "administrator",
+    operation_identity: null,
+    expires_at: null,
+}));
 const parseLoaderArgs = (encoded) => {
     if (encoded === undefined)
         return ok([]);
@@ -107,6 +136,32 @@ export const parseConfig = (environment) => {
     const secretPatterns = parseStringArray(parsedEnvironment.data.REA_REFERENCE_SECRET_PATTERNS_JSON, "REA_REFERENCE_SECRET_PATTERNS_JSON");
     if (!secretPatterns.ok)
         return secretPatterns;
+    const permissionCeilings = [
+        ...(parsedEnvironment.data.REA_PROCESS_CAPTURE_ENABLED === "true"
+            ? [
+                permissionScope("process_capture", workingRoots.value, {
+                    executables: executableRoots.value,
+                    environment_names: allowedEnvironment.value,
+                    network: parsedEnvironment.data.REA_PROCESS_ALLOW_EXTERNAL_NETWORK ===
+                        "true"
+                        ? "external"
+                        : "none",
+                }),
+            ]
+            : []),
+        permissionScope("evidence_read", evidenceRoots.value),
+        permissionScope("evidence_write", evidenceRoots.value),
+        permissionScope("investigation_input", investigationInputRoots.value),
+        permissionScope("investigation_workspace_read", evidenceRoots.value),
+        permissionScope("investigation_workspace_write", evidenceRoots.value),
+        permissionScope("snapshot_read", analysisSnapshotRoots.value),
+        permissionScope("snapshot_write", analysisSnapshotRoots.value),
+        permissionScope("artifact_extract", ["/"]),
+        permissionScope("reference_read", referenceRoots.value),
+        ...(parsedEnvironment.data.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true"
+            ? [permissionScope("native_mount", [], { mount: true })]
+            : []),
+    ];
     return ok({
         hopperLauncherPath: parsedEnvironment.data.HOPPER_LAUNCHER_PATH ??
             defaultHopperLauncherPath(),
@@ -122,6 +177,7 @@ export const parseConfig = (environment) => {
             allowExternalNetwork: parsedEnvironment.data.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true",
         },
         artifactNativeMountEnabled: parsedEnvironment.data.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true",
+        artifactIntegrityContinueEnabled: parsedEnvironment.data.REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED === "true",
         evidenceFilePolicy: filePolicy(evidenceRoots.value),
         investigationInputRoots: investigationInputRoots.value,
         analysisSnapshotFilePolicy: filePolicy(analysisSnapshotRoots.value),
@@ -133,5 +189,9 @@ export const parseConfig = (environment) => {
             maxDepth: 32,
             maxPathBytes: 4_096,
         },
+        permissionCeilings,
+        administratorPermissionGrants: administratorGrants(permissionCeilings),
+        permissionProjectRoot: parsedEnvironment.data.REA_PERMISSION_PROJECT_ROOT,
+        permissionProjectStore: parsedEnvironment.data.REA_PERMISSION_PROJECT_STORE,
     });
 };

package/dist/contracts/artifactToolContracts.js

@@ -28,10 +28,23 @@ const traversalLimitsInput = {
     max_path_bytes: z.number().int().min(1).max(65_535).default(4_096),
 };
 /** Exact caller boundary for deterministic artifact inventory. */
-export const artifactInventoryInputSchema = z.object({
+export const artifactInventoryInputSchema = z
+    .object({
     native_mount_approved: z.boolean().default(false),
+    integrity_policy: z.enum(["fail", "record-and-continue"]).default("fail"),
+    integrity_continue_approved: z.boolean().default(false),
+    max_integrity_mismatches: z.number().int().min(1).max(100).default(10),
     ...pageInput,
     ...traversalLimitsInput,
+})
+    .superRefine((input, context) => {
+    if (input.integrity_policy === "record-and-continue" &&
+        input.integrity_continue_approved !== true)
+        context.addIssue({
+            code: "custom",
+            path: ["integrity_continue_approved"],
+            message: "record-and-continue requires explicit approval",
+        });
 });
 /** Exact caller boundary for approved artifact extraction. */
 export const artifactExtractionInputSchema = z.object({