rea-agents 1.2.0 → 1.4.0

package/dist/cliEvidenceCommands.js

@@ -2,6 +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 { 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", {
@@ -12,11 +14,14 @@ export const registerEvidenceCommands = (cli, logger) => {
         run: ({ args }) => logCliCommand(logger, "evidence-import", async () => {
             const config = parseConfig(process.env);
             if (!config.ok)
-                return { error: config.error._tag, message: config.error.message };
+                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
-                : { error: imported.error._tag, message: imported.error.message };
+            return imported.ok ? imported.value : cliError(imported.error);
         }),
     });
     cli.command("evidence-export", {
@@ -31,11 +36,15 @@ export const registerEvidenceCommands = (cli, logger) => {
         run: ({ args, options }) => logCliCommand(logger, "evidence-export", async () => {
             const config = parseConfig(process.env);
             if (!config.ok)
-                return { error: config.error._tag, message: config.error.message };
+                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
-                : { error: exported.error._tag, message: exported.error.message };
+            return exported.ok ? exported.value : cliError(exported.error);
         }),
     });
     cli.command("compare", {
@@ -52,7 +61,13 @@ export const registerEvidenceCommands = (cli, logger) => {
         run: ({ args, options }) => logCliCommand(logger, "compare", async () => {
             const config = parseConfig(process.env);
             if (!config.ok)
-                return { error: config.error._tag, message: config.error.message };
+                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,
@@ -60,9 +75,34 @@ export const registerEvidenceCommands = (cli, logger) => {
                 limit: options.limit,
                 policy: config.value.evidenceFilePolicy,
             });
-            return compared.ok
-                ? compared.value
-                : { error: compared.error._tag, message: compared.error.message };
+            return compared.ok ? compared.value : cliError(compared.error);
         }),
     });
 };
+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

@@ -0,0 +1,137 @@
+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()
+        .default(false)
+        .describe("Approve persistent workspace writes"),
+    workspaceName: z.string().trim().min(1).max(200).default("default"),
+    expectedRevision: z.number().int().min(1).optional(),
+    maxEntries: z.number().int().min(1).max(50_000).default(10_000),
+    maxTotalBytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(Number.MAX_SAFE_INTEGER)
+        .default(1_073_741_824),
+    maxEntryBytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(Number.MAX_SAFE_INTEGER)
+        .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) => {
+    cli.command("investigate-versions", {
+        description: "Run or resume a persistent cross-version artifact investigation",
+        args: z.object({
+            leftPath: z.string().describe("Earlier artifact or directory path"),
+            rightPath: z.string().describe("Later artifact or directory path"),
+            workspacePath: z.string().describe("Persistent workspace JSON path"),
+        }),
+        options: investigationOptionsSchema,
+        alias: {
+            workspaceName: "workspace-name",
+            expectedRevision: "expected-revision",
+            maxEntries: "max-entries",
+            maxTotalBytes: "max-total-bytes",
+            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)),
+    });
+};
+const runInvestigation = async (args, options) => {
+    if (!options.yes)
+        return {
+            error: "ApprovalRequired",
+            message: "Persistent workspace writes require explicit --yes approval.",
+        };
+    const config = parseConfig(process.env);
+    if (!config.ok)
+        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,
+        workspace_name: options.workspaceName,
+        ...(options.expectedRevision === undefined
+            ? {}
+            : { 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,
+            max_entry_bytes: options.maxEntryBytes,
+            max_compression_ratio: 1_000,
+            max_depth: 20,
+            max_path_bytes: 4_096,
+            page_size: options.pageSize,
+            change_limit: options.changeLimit,
+        },
+    }, config.value.evidenceFilePolicy, {
+        inputRoots: config.value.investigationInputRoots,
+        integrityContinueEnabled: config.value.artifactIntegrityContinueEnabled,
+    });
+    return investigated.ok
+        ? investigated.value.evidence
+        : 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/cliOutput.js

@@ -0,0 +1,41 @@
+const SAFE_VALIDATION_MESSAGE = "REA could not read the command arguments. Run `rea --help`, correct the arguments, then try again.";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const validationError = (value) => {
+    if (!isRecord(value))
+        return undefined;
+    if (value.code === "VALIDATION_ERROR")
+        return value;
+    if (value.ok === false && isRecord(value.error))
+        return value.error.code === "VALIDATION_ERROR" ? value.error : undefined;
+    return undefined;
+};
+/** Remove validator internals from Incur's caller-visible CLI output. */
+export const sanitizeCliOutput = (output) => {
+    const trimmed = output.trimStart();
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            const error = validationError(parsed);
+            if (error !== undefined) {
+                const safeError = {
+                    code: "VALIDATION_ERROR",
+                    message: SAFE_VALIDATION_MESSAGE,
+                };
+                if (error === parsed)
+                    return `${JSON.stringify(safeError)}\n`;
+                if (!isRecord(parsed))
+                    return output;
+                return `${JSON.stringify({ ...parsed, error: safeError })}\n`;
+            }
+        }
+        catch {
+            return output;
+        }
+        return output;
+    }
+    if (/^ok: false\r?\nerror:\r?\n  code: VALIDATION_ERROR(?:\r?\n|$)/u.test(trimmed))
+        return `ok: false\nerror:\n  code: VALIDATION_ERROR\n  message: "${SAFE_VALIDATION_MESSAGE}"\n`;
+    if (!/^code: VALIDATION_ERROR(?:\r?\n|$)/u.test(trimmed))
+        return output;
+    return `code: VALIDATION_ERROR\nmessage: "${SAFE_VALIDATION_MESSAGE}"\n`;
+};

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/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"),
@@ -22,8 +30,16 @@ const environmentSchema = z.object({
     REA_PROCESS_WORKING_ROOTS_JSON: z.string().default("[]"),
     REA_PROCESS_ALLOWED_ENV_JSON: z.string().default("[]"),
     REA_EVIDENCE_ROOTS_JSON: z.string().default("[]"),
+    REA_INVESTIGATION_INPUT_ROOTS_JSON: z.string().default("[]"),
+    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 {
@@ -41,6 +57,45 @@ const parseStringArray = (encoded, name) => {
         return err(new ConfigurationError(`${name} must be valid JSON`, { cause }));
     }
 };
+const filePolicy = (roots) => ({
+    roots,
+    maxBytes: 64 * 1024 * 1024,
+    maxDepth: 64,
+    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([]);
+    let decoded;
+    try {
+        decoded = JSON.parse(encoded);
+    }
+    catch (cause) {
+        return err(new ConfigurationError("HOPPER_LOADER_ARGS_JSON must be valid JSON", {
+            cause,
+        }));
+    }
+    const parsed = z.array(z.string()).safeParse(decoded);
+    return parsed.success
+        ? ok(parsed.data)
+        : err(new ConfigurationError("HOPPER_LOADER_ARGS_JSON must encode an array of strings", { cause: parsed.error }));
+};
 /**
  * Parse Hopper launcher configuration once at the composition root.
  * Explicit loader arguments override REA's header-derived defaults for a
@@ -54,22 +109,9 @@ export const parseConfig = (environment) => {
             cause: parsedEnvironment.error,
         }));
     }
-    let loaderArgs = [];
-    const encoded = parsedEnvironment.data.HOPPER_LOADER_ARGS_JSON;
-    if (encoded !== undefined) {
-        try {
-            loaderArgs = JSON.parse(encoded);
-        }
-        catch (cause) {
-            return err(new ConfigurationError("HOPPER_LOADER_ARGS_JSON must be valid JSON", {
-                cause,
-            }));
-        }
-    }
-    const parsedArgs = z.array(z.string()).safeParse(loaderArgs);
-    if (!parsedArgs.success) {
-        return err(new ConfigurationError("HOPPER_LOADER_ARGS_JSON must encode an array of strings", { cause: parsedArgs.error }));
-    }
+    const loaderArgs = parseLoaderArgs(parsedEnvironment.data.HOPPER_LOADER_ARGS_JSON);
+    if (!loaderArgs.ok)
+        return loaderArgs;
     const executableRoots = parseStringArray(parsedEnvironment.data.REA_PROCESS_EXECUTABLE_ROOTS_JSON, "REA_PROCESS_EXECUTABLE_ROOTS_JSON");
     if (!executableRoots.ok)
         return executableRoots;
@@ -82,18 +124,50 @@ export const parseConfig = (environment) => {
     const evidenceRoots = parseStringArray(parsedEnvironment.data.REA_EVIDENCE_ROOTS_JSON, "REA_EVIDENCE_ROOTS_JSON");
     if (!evidenceRoots.ok)
         return evidenceRoots;
+    const investigationInputRoots = parseStringArray(parsedEnvironment.data.REA_INVESTIGATION_INPUT_ROOTS_JSON, "REA_INVESTIGATION_INPUT_ROOTS_JSON");
+    if (!investigationInputRoots.ok)
+        return investigationInputRoots;
+    const analysisSnapshotRoots = parseStringArray(parsedEnvironment.data.REA_ANALYSIS_SNAPSHOT_ROOTS_JSON, "REA_ANALYSIS_SNAPSHOT_ROOTS_JSON");
+    if (!analysisSnapshotRoots.ok)
+        return analysisSnapshotRoots;
     const referenceRoots = parseStringArray(parsedEnvironment.data.REA_REFERENCE_ROOTS_JSON, "REA_REFERENCE_ROOTS_JSON");
     if (!referenceRoots.ok)
         return referenceRoots;
     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(),
         hopperTargetPath: parsedEnvironment.data.HOPPER_TARGET_PATH,
         hopperTargetKind: parsedEnvironment.data.HOPPER_TARGET_KIND,
-        hopperLoaderArgs: parsedArgs.data,
+        hopperLoaderArgs: loaderArgs.value,
         logLevel: parsedEnvironment.data.REA_LOG_LEVEL,
         processExecutionPolicy: {
             enabled: parsedEnvironment.data.REA_PROCESS_CAPTURE_ENABLED === "true",
@@ -103,13 +177,10 @@ export const parseConfig = (environment) => {
             allowExternalNetwork: parsedEnvironment.data.REA_PROCESS_ALLOW_EXTERNAL_NETWORK === "true",
         },
         artifactNativeMountEnabled: parsedEnvironment.data.REA_ARTIFACT_NATIVE_MOUNT_ENABLED === "true",
-        evidenceFilePolicy: {
-            roots: evidenceRoots.value,
-            maxBytes: 64 * 1024 * 1024,
-            maxDepth: 64,
-            maxStringLength: 1024 * 1024,
-            maxNodes: 1_000_000,
-        },
+        artifactIntegrityContinueEnabled: parsedEnvironment.data.REA_ARTIFACT_INTEGRITY_CONTINUE_ENABLED === "true",
+        evidenceFilePolicy: filePolicy(evidenceRoots.value),
+        investigationInputRoots: investigationInputRoots.value,
+        analysisSnapshotFilePolicy: filePolicy(analysisSnapshotRoots.value),
         referenceSourcePolicy: {
             roots: referenceRoots.value,
             secretPatterns: secretPatterns.value,
@@ -118,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({