rea-agents 6.3.0 → 6.5.0

package/dist/composition/binaryDiagnostics.js

@@ -2,6 +2,10 @@ import { RecordedCrashService } from "../application/binaryDiagnostics/RecordedC
 import { PwntoolsRecordedCrashProvider } from "../native/pwntools/PwntoolsRecordedCrashProvider.js";
 import { BinaryLayoutService } from "../application/binaryDiagnostics/BinaryLayoutService.js";
 import { PwntoolsLayoutProvider } from "../native/pwntools/PwntoolsLayoutProvider.js";
+import { PeResourcesService } from "../application/binaryDiagnostics/PeResourcesService.js";
+import { PeResourcesProvider } from "../native/pe/PeResourcesProvider.js";
+/** Portable PE inspection with no engine, installation or target acquisition. */
+export const createPeResourcesService = () => new PeResourcesService(new PeResourcesProvider());
 /** Compose the offline adapter without import-time I/O or dependency acquisition. */
 export const createBinaryLayoutService = (environment = process.env) => new BinaryLayoutService(new PwntoolsLayoutProvider(environment));
 /** Compose recorded-core inspection without acquiring a debugger or toolchain. */

package/dist/composition/captures.js

@@ -0,0 +1,3 @@
+import { PacketCaptureService } from "../application/captures/PacketCaptureService.js";
+import { TsharkCaptureProvider } from "../captures/TsharkCaptureProvider.js";
+export const createPacketCaptureService = (environment = process.env) => new PacketCaptureService(new TsharkCaptureProvider(environment));

package/dist/composition/directAnalysis.js

@@ -1,23 +1,48 @@
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { parseConfig } from "../config/parseConfig.js";
-import { runDirectAnalysis as executeDirectAnalysis, runProviderAnalysis as executeProviderAnalysis, runManagedProviderExecution as executeManagedProvider, } from "../application/DirectAnalysis.js";
-import { runSessionStatus as executeSessionStatus } from "../application/DirectAnalysisStatus.js";
-import { createBinarySession, createManagedBinarySession } from "./binary.js";
 /** Bind one-shot analysis and status commands to one caller-selected environment. */
 export const createDirectAnalysis = (selectedEnvironment) => {
     const environment = snapshotEnvironment(selectedEnvironment);
     const dependencies = {
         readConfiguration: () => parseConfig(environment),
-        createBinarySession: (config, logger) => createBinarySession(config, logger, environment),
-        createManagedBinarySession,
+        createBinarySession: async (config, logger) => {
+            const { createBinarySession } = await import("./binary.js");
+            return createBinarySession(config, logger, environment);
+        },
+        createManagedBinarySession: async () => {
+            const { createManagedBinarySession } = await import("./binary.js");
+            return createManagedBinarySession();
+        },
+        createArtifactBinarySession: async () => {
+            const { createArtifactBinarySession } = await import("./binary.js");
+            return createArtifactBinarySession(environment);
+        },
+    };
+    const runDirectAnalysis = async (...args) => {
+        const { runDirectAnalysis } = await import("../application/DirectAnalysis.js");
+        return runDirectAnalysis(dependencies, ...args);
+    };
+    const runProviderAnalysis = async (...args) => {
+        const { runProviderAnalysis } = await import("../application/DirectAnalysis.js");
+        return runProviderAnalysis(dependencies, ...args);
+    };
+    const runSessionStatus = async (...args) => {
+        const { runSessionStatus } = await import("../application/DirectAnalysisStatus.js");
+        return runSessionStatus(dependencies, ...args);
     };
     return {
-        runDirectAnalysis: executeDirectAnalysis.bind(undefined, dependencies),
-        runProviderAnalysis: executeProviderAnalysis.bind(undefined, dependencies),
-        runSessionStatus: executeSessionStatus.bind(undefined, dependencies),
+        runDirectAnalysis,
+        runProviderAnalysis,
+        runSessionStatus,
     };
 };
 /** Execute managed metadata without configuration or native provider candidates. */
-export const runManagedProviderExecution = executeManagedProvider.bind(undefined, {
-    createManagedBinarySession,
-});
+export const runManagedProviderExecution = async (...args) => {
+    const { runManagedProviderExecution } = await import("../application/DirectAnalysis.js");
+    return runManagedProviderExecution({
+        createManagedBinarySession: async () => {
+            const { createManagedBinarySession } = await import("./binary.js");
+            return createManagedBinarySession();
+        },
+    }, ...args);
+};

package/dist/composition/electronFuses.js

@@ -0,0 +1,4 @@
+import { ElectronFuseService } from "../application/electron/ElectronFuseService.js";
+import { ElectronFuseProvider } from "../electron/ElectronFuseProvider.js";
+/** Compose read-only fuse inspection without a runtime, network, or fuse edit. */
+export const createElectronFuseService = () => new ElectronFuseService(new ElectronFuseProvider());

package/dist/composition/evm.js

@@ -1,4 +1,16 @@
 import { EvmInterfaceService } from "../application/evm/EvmInterfaceService.js";
 import { EvmoleInterfaceProvider } from "../evm/EvmoleInterfaceProvider.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { INSPECT_EVM_INTERFACE_CONTRACT } from "../contracts/evm/evmToolContracts.js";
 /** Compose offline interface analysis without import-time I/O or dependency acquisition. */
 export const createEvmInterfaceService = (environment = process.env) => new EvmInterfaceService(new EvmoleInterfaceProvider(environment));
+/**
+ * Static binding of the existing operation, command and fresh service factory.
+ * The host owns injected service identity and its retryable cleanup lifetime.
+ * Construction performs no acquisition, target I/O or import-time execution.
+ */
+export const evmInterfaceModule = {
+    contract: INSPECT_EVM_INTERFACE_CONTRACT,
+    cliCommand: CLI_COMMANDS.inspectEvmInterface,
+    create: createEvmInterfaceService,
+};

package/dist/composition/flutter.js

@@ -0,0 +1,3 @@
+import { FlutterBuildProvider } from "../flutter/FlutterBuildProvider.js";
+/** Construct one Flutter provider; it needs no external tools. */
+export const createFlutterBuildAnalysisProvider = () => new FlutterBuildProvider();

package/dist/composition/go.js

@@ -0,0 +1,4 @@
+import { GoBinaryService } from "../application/go/GoBinaryService.js";
+import { GoBinaryProvider } from "../go/GoBinaryProvider.js";
+/** Compose bundled offline inspection without acquiring a toolchain or starting any process. */
+export const createGoBinaryService = () => new GoBinaryService(new GoBinaryProvider());

package/dist/composition/javascriptAnalysisWorkerProcess.js

@@ -0,0 +1,49 @@
+import { moduleResolutionModeForJavaScriptReference } from "../domain/javascript/javascriptModuleResolutionMode.js";
+import { parseJavaScriptSource } from "../domain/javascript/javascriptSourceParser.js";
+import { analyzeParsedJavaScriptStaticSourceSteps } from "../domain/javascript/javascriptStaticAnalysis.js";
+import { analyzeParsedJavaScriptSemanticsSteps, classifyParsedJavaScriptOpenReceiversSteps, } from "../domain/javascript/javascriptSemanticAnalysis.js";
+import { failedJavaScriptStaticAnalysis } from "../domain/javascript/javascriptStaticAnalysisHelpers.js";
+import { projectJavaScriptModuleSemantics } from "../domain/javascript/javascriptModuleSemanticIr.js";
+import { javaScriptTransferByteBudget, measureJavaScriptModuleTransfer, } from "../javascript/analysis/JavaScriptAnalysisTransfer.js";
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { projectJavaScriptSemanticFileSteps } from "../application/javascript/JavaScriptSemanticGraphBuilder.js";
+import { completeJavaScriptAnalysisSteps } from "../application/javascript/JavaScriptAnalysisControl.js";
+import { serveJavaScriptAnalysisWorker, } from "../javascript/analysis/JavaScriptAnalysisWorkerServer.js";
+const analyze = async (file, nodeBudget, callbacks) => {
+    if (!file.text.included)
+        throw new TypeError("JavaScript worker requires decoded source text");
+    await callbacks.phase("parse");
+    let parsed = parseJavaScriptSource(file.text.value, file.path);
+    if (parsed === null) {
+        await callbacks.checkpoint(failedJavaScriptStaticAnalysis());
+        return null;
+    }
+    await callbacks.phase("static");
+    const receivers = await completeJavaScriptAnalysisSteps(classifyParsedJavaScriptOpenReceiversSteps(parsed));
+    const facts = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed, receivers));
+    const resultBudgetBytes = await callbacks.checkpoint(facts);
+    if (facts.parse_status === "failed")
+        return null;
+    if (resultBudgetBytes === 0)
+        throw new AnalysisResourceConstraintError("analyze_javascript_application", "memory", `The parent reserved its remaining result capacity for static observations; semantic analysis of ${file.path} was not started`, { semantic_result_budget_bytes: 0 });
+    await callbacks.phase("semantic");
+    const ir = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptSemanticsSteps(parsed, moduleResolutionModeForJavaScriptReference(file.path, "static-import")));
+    parsed = null;
+    const module = projectJavaScriptModuleSemantics(ir);
+    const measured = measureJavaScriptModuleTransfer(module, javaScriptTransferByteBudget(resultBudgetBytes));
+    if (measured.retentionBytes > resultBudgetBytes)
+        throw new AnalysisResourceConstraintError("analyze_javascript_application", "memory", `Completed module facts for ${file.path} exceed the parent's offered result budget; static facts were retained`, {
+            semantic_result_budget_bytes: resultBudgetBytes,
+            module_transfer_bytes: measured.bytes,
+        });
+    await callbacks.phase("projection");
+    const projection = await completeJavaScriptAnalysisSteps(projectJavaScriptSemanticFileSteps(file, ir, nodeBudget, facts.electron.call_paths));
+    return { module, projection };
+};
+try {
+    await serveJavaScriptAnalysisWorker(analyze);
+}
+catch (cause) {
+    process.stderr.write(`${cause instanceof Error ? cause.message : String(cause)}\n`);
+    process.exitCode = 1;
+}

package/dist/composition/jeb.js

@@ -0,0 +1,35 @@
+import { ConfigurationError } from "../domain/configurationErrors.js";
+import { err } from "../domain/result.js";
+import { parseJebMcpEndpoint } from "../jeb/JebMcpEndpoint.js";
+import { JebProvider } from "../jeb/JebProvider.js";
+/**
+ * Construct one JEB provider bound to the caller-selected MCP endpoint. An
+ * unusable endpoint makes only JEB unavailable; every other CLI command and
+ * MCP tool is composed alongside it.
+ */
+export const createJebAnalysisProvider = (environment = process.env, connectionFactory) => {
+    const endpoint = parseJebMcpEndpoint(environment.REA_JEB_MCP_URL);
+    if (!endpoint.ok) {
+        const constraint = typeof endpoint.error.cause === "string"
+            ? endpoint.error.cause
+            : endpoint.error.message;
+        return unconfiguredJebProvider(new ConfigurationError("Invalid REA environment configuration", {
+            cause: endpoint.error,
+            settings: [{ setting: "REA_JEB_MCP_URL", constraint }],
+        }));
+    }
+    return new JebProvider({
+        environment,
+        ...(connectionFactory === undefined ? {} : { connectionFactory }),
+    });
+};
+const unconfiguredJebProvider = (error) => ({
+    inspectAvailability: () => Promise.resolve({
+        status: "unavailable",
+        code: "not_configured",
+        reason: `REA_JEB_MCP_URL is invalid: ${error.settings[0]?.constraint ?? error.message}`,
+        diagnostics: { setting: "REA_JEB_MCP_URL" },
+    }),
+    close: () => Promise.resolve(),
+    execute: () => Promise.resolve(err(error)),
+});

package/dist/composition/pcap.js

@@ -0,0 +1,3 @@
+import { PcapProvider } from "../pcap/PcapProvider.js";
+/** Construct one pcap provider bound to the caller-selected tools. */
+export const createPcapAnalysisProvider = (environment = process.env) => new PcapProvider({ environment });

package/dist/composition/resolveWindowsProviderExecutable.js

@@ -0,0 +1,61 @@
+import { existsSync, statSync } from "node:fs";
+import { win32 } from "node:path";
+const splitWindowsPath = (value) => {
+    const entries = [];
+    let start = 0;
+    let quoted = false;
+    for (let index = 0; index < value.length; index += 1) {
+        if (value[index] === '"')
+            quoted = !quoted;
+        else if (value[index] === ";" && !quoted) {
+            entries.push(value.slice(start, index));
+            start = index + 1;
+        }
+    }
+    entries.push(value.slice(start));
+    return entries.flatMap((entry) => {
+        if (entry.startsWith('"') && entry.endsWith('"') && entry.length >= 2)
+            return [entry.slice(1, -1)];
+        return entry.includes('"') ? [] : [entry];
+    });
+};
+const isRegularFile = (path) => {
+    try {
+        return existsSync(path) && statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+/** Resolve Windows bare command names against the captured child environment. */
+export const resolveWindowsProviderExecutable = (executable, environment, lookup = {}) => {
+    const cwd = lookup.cwd ?? process.cwd();
+    const absolute = (...paths) => win32.resolve(cwd, ...paths);
+    if (win32.isAbsolute(executable) ||
+        executable.includes("/") ||
+        executable.includes("\\") ||
+        win32.parse(executable).root !== "")
+        return absolute(executable);
+    const pathValue = environment.PATH ?? environment.Path ?? environment.path;
+    if (pathValue === undefined)
+        return executable;
+    const pathEntries = splitWindowsPath(pathValue);
+    const explicitExtension = win32.extname(executable).toLowerCase();
+    if (explicitExtension !== "" && ![".com", ".exe"].includes(explicitExtension))
+        return executable;
+    const extensions = explicitExtension !== ""
+        ? [""]
+        : (environment.PATHEXT ?? environment.PathExt ?? ".COM;.EXE")
+            .split(";")
+            .filter((extension) => [".com", ".exe"].includes(extension.toLowerCase()));
+    for (const entry of pathEntries) {
+        if (entry.length === 0)
+            continue;
+        for (const extension of extensions) {
+            const candidate = absolute(entry, `${executable}${extension}`);
+            if ((lookup.isFile ?? isRegularFile)(candidate))
+                return candidate;
+        }
+    }
+    return executable;
+};

package/dist/composition/reverseEngineering.js

@@ -0,0 +1,29 @@
+import { ReverseEngineeringService } from "../application/reverse/ReverseEngineeringService.js";
+import { objdumpCommand, OBJDUMP_PROVIDER_IDENTITY, } from "../objdump/ObjdumpCommand.js";
+import { rizinCommand, RIZIN_PROVIDER_IDENTITY, } from "../rizin/RizinCommand.js";
+import { resolveWindowsProviderExecutable } from "./resolveWindowsProviderExecutable.js";
+export const createReverseEngineeringCommandPort = (environment, platform = process.platform) => ({
+    objdump: (input) => ({
+        executable: providerExecutable(environment.REA_OBJDUMP_COMMAND ?? "objdump", environment, platform),
+        arguments: objdumpCommand(input),
+        identity: OBJDUMP_PROVIDER_IDENTITY,
+        environmentOverrides: { DEBUGINFOD_URLS: "" },
+    }),
+    rizin: (input) => ({
+        executable: providerExecutable(environment.REA_RIZIN_COMMAND ?? "rizin", environment, platform),
+        arguments: rizinCommand(input),
+        identity: RIZIN_PROVIDER_IDENTITY,
+    }),
+});
+const providerExecutable = (executable, environment, platform) => platform === "win32"
+    ? resolveWindowsProviderExecutable(executable, environment)
+    : executable;
+/** Compose BYO reverse-engineering commands without acquiring tools at import time. */
+export const createReverseEngineeringService = (environment = process.env, options = {}) => {
+    const environmentSnapshot = { ...environment };
+    return new ReverseEngineeringService({
+        ...options,
+        environment: environmentSnapshot,
+        commands: createReverseEngineeringCommandPort(environmentSnapshot),
+    });
+};

package/dist/composition/rust.js

@@ -0,0 +1,4 @@
+import { RustBinaryService } from "../application/rust/RustBinaryService.js";
+import { RustBinaryProvider } from "../rust/RustBinaryProvider.js";
+/** Compose bundled offline inspection without a Rust toolchain or any child process. */
+export const createRustBinaryService = () => new RustBinaryService(new RustBinaryProvider());

package/dist/composition/signals.js

@@ -0,0 +1,3 @@
+import { SignalRecordingService } from "../application/signals/SignalRecordingService.js";
+import { SigrokRecordingProvider } from "../signals/SigrokRecordingProvider.js";
+export const createSignalRecordingService = (environment = process.env) => new SignalRecordingService(new SigrokRecordingProvider(environment));

package/dist/composition/sqlite.js

@@ -0,0 +1,4 @@
+import { SqliteDatabaseService } from "../application/sqlite/SqliteDatabaseService.js";
+import { SqliteDatabaseProvider } from "../sqlite/SqliteDatabaseProvider.js";
+/** Compose local snapshot inspection without opening a native analysis provider. */
+export const createSqliteDatabaseService = (environment = process.env) => new SqliteDatabaseService(new SqliteDatabaseProvider(environment));

package/dist/composition/wasm.js

@@ -0,0 +1,22 @@
+import { WasmArtifactService } from "../application/wasm/WasmArtifactService.js";
+import { WabtArtifactProvider } from "../wasm/WabtArtifactProvider.js";
+import { INSPECT_WASM_ARTIFACT_CONTRACT } from "../contracts/wasm/wasmToolContracts.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+/** Compose the caller-supplied offline toolchain without acquisition or import-time I/O. */
+export const createWasmArtifactService = (environment = process.env) => new WasmArtifactService(new WabtArtifactProvider(environment));
+/**
+ * Internal static descriptor for one named domain operation and its lifetime.
+ * CLI/MCP share this binding; the service keeps failed resource ownership so
+ * close can be retried. Construction performs no acquisition or target I/O.
+ */
+export const wasmArtifactModule = {
+    contract: INSPECT_WASM_ARTIFACT_CONTRACT,
+    cliCommand: CLI_COMMANDS.inspectWasmArtifact,
+    create(environment, injected) {
+        const service = injected ?? createWasmArtifactService(environment);
+        return {
+            inspect: service.inspect.bind(service),
+            close: service.close.bind(service),
+        };
+    },
+};

package/dist/composition/webNetworkCaptures.js

@@ -1,6 +1,11 @@
 import { WebNetworkCaptureService } from "../application/WebNetworkCaptureService.js";
 import { HistoricalCaptureDecoder } from "../browser/history/HistoricalCaptureDecoder.js";
-import { HarCaptureAdapter } from "../browser/history/HarCaptureAdapter.js";
+import { NodeCaptureAdapter } from "../browser/history/NodeCaptureAdapter.js";
 import { MitmproxyCaptureAdapter } from "../browser/history/MitmproxyCaptureAdapter.js";
 /** Compose offline format adapters without import-time reads, installation or process startup. */
-export const createWebNetworkCaptureService = (environment = process.env) => new WebNetworkCaptureService(new HistoricalCaptureDecoder([new HarCaptureAdapter(), new MitmproxyCaptureAdapter(environment)], environment));
+export const createWebNetworkCaptureService = (environment = process.env) => new WebNetworkCaptureService(new HistoricalCaptureDecoder([
+    new NodeCaptureAdapter("har"),
+    new NodeCaptureAdapter("saz"),
+    new NodeCaptureAdapter("qlog"),
+    new MitmproxyCaptureAdapter(environment),
+], environment));

package/dist/config/environment.js

@@ -3,11 +3,18 @@ import { isAbsolute } from "node:path";
 import { ConfigurationError } from "../domain/configurationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { analysisProviderSelectorSchema } from "../contracts/providerSelection.js";
-import { ghidraStartupTimeoutSchema } from "./ghidraStartupTimeout.js";
+import { ghidraCompilerSpecIdSchema, ghidraLanguageIdSchema, } from "./ghidraLanguageOverride.js";
+import { ghidraDisabledAnalyzersSchema } from "./ghidraDisabledAnalyzers.js";
+import { DEFAULT_GHIDRA_STARTUP_TIMEOUT_MS, DEFAULT_HOPPER_STARTUP_TIMEOUT_MS, DEFAULT_SWIFTC_COMPILE_TIMEOUT_MS, providerStartupTimeoutSchema, } from "./providerStartupTimeout.js";
+import { mcpInputSchemaProfileSchema } from "./mcpInputSchemaProfile.js";
+import { mcpOutputSchemaProfileSchema } from "./mcpOutputSchemaProfile.js";
 import { mcpResponseBudgetSchema } from "./mcpResponseBudget.js";
+import { parseLoaderArgs, parseStringArray } from "./parsers.js";
 const environmentSchema = z.object({
     REA_ANALYSIS_PROVIDER: analysisProviderSelectorSchema.default("auto"),
     REA_MCP_MAX_RESPONSE_BYTES: mcpResponseBudgetSchema.optional(),
+    REA_MCP_INPUT_SCHEMA_PROFILE: mcpInputSchemaProfileSchema.optional(),
+    REA_MCP_OUTPUT_SCHEMA_PROFILE: mcpOutputSchemaProfileSchema.optional(),
     REA_IDA_MCP_CONFIG: z
         .string()
         .min(1)
@@ -28,7 +35,17 @@ const environmentSchema = z.object({
         .min(1)
         .refine(isAbsolute, "REA_GHIDRA_NATIVEAOT_JAR must be absolute")
         .optional(),
-    REA_GHIDRA_STARTUP_TIMEOUT_MS: ghidraStartupTimeoutSchema,
+    REA_GHIDRA_STARTUP_TIMEOUT_MS: providerStartupTimeoutSchema.default(DEFAULT_GHIDRA_STARTUP_TIMEOUT_MS),
+    REA_HOPPER_STARTUP_TIMEOUT_MS: providerStartupTimeoutSchema.default(DEFAULT_HOPPER_STARTUP_TIMEOUT_MS),
+    REA_SWIFTC_COMPILE_TIMEOUT_MS: providerStartupTimeoutSchema.default(DEFAULT_SWIFTC_COMPILE_TIMEOUT_MS),
+    REA_GHIDRA_LANGUAGE_ID: ghidraLanguageIdSchema.optional(),
+    REA_GHIDRA_COMPILER_SPEC_ID: ghidraCompilerSpecIdSchema.optional(),
+    REA_GHIDRA_DISABLED_ANALYZERS: ghidraDisabledAnalyzersSchema.optional(),
+    REA_GHIDRA_SEED_FILE: z
+        .string()
+        .min(1)
+        .refine(isAbsolute, "REA_GHIDRA_SEED_FILE must be absolute")
+        .optional(),
     REA_ILSPY_CMD_PATH: z
         .string()
         .min(1)
@@ -43,7 +60,8 @@ const environmentSchema = z.object({
         .default("info"),
     REA_REFERENCE_SECRET_PATTERNS_JSON: z.string().default("[]"),
 });
-export const parseEnvironment = (environment) => {
+/** Parse individual settings before layered registration fragments are merged. */
+export const parseEnvironmentValues = (environment) => {
     const parsed = environmentSchema.safeParse(environment);
     if (!parsed.success) {
         // Zod messages name the constraint, never the rejected value.
@@ -56,5 +74,38 @@ export const parseEnvironment = (environment) => {
             settings,
         }));
     }
-    return ok(parsed.data);
+    const { HOPPER_LOADER_ARGS_JSON: encodedLoaderArgs, REA_REFERENCE_SECRET_PATTERNS_JSON: encodedSecretPatterns, ...env } = parsed.data;
+    const loaderArgs = parseLoaderArgs(encodedLoaderArgs);
+    if (!loaderArgs.ok)
+        return loaderArgs;
+    const secretPatterns = parseStringArray(encodedSecretPatterns, "REA_REFERENCE_SECRET_PATTERNS_JSON");
+    if (!secretPatterns.ok)
+        return secretPatterns;
+    return ok({
+        ...env,
+        loaderArgs: loaderArgs.value,
+        referenceSecretPatterns: secretPatterns.value,
+    });
+};
+/** Validate complete runtime semantics without probing the host or persisting defaults. */
+export const parseEnvironment = (environment, 
+// Registration expressions are not evaluated; their absence is not proven.
+unresolvedSettings = new Set()) => {
+    const parsed = parseEnvironmentValues(environment);
+    if (!parsed.ok)
+        return parsed;
+    const env = parsed.value;
+    // Ghidra's analyzeHeadless accepts -cspec only together with -processor.
+    if (env.REA_GHIDRA_COMPILER_SPEC_ID !== undefined &&
+        env.REA_GHIDRA_LANGUAGE_ID === undefined &&
+        !unresolvedSettings.has("REA_GHIDRA_LANGUAGE_ID"))
+        return err(new ConfigurationError("Invalid REA environment configuration", {
+            settings: [
+                {
+                    setting: "REA_GHIDRA_COMPILER_SPEC_ID",
+                    constraint: "requires REA_GHIDRA_LANGUAGE_ID",
+                },
+            ],
+        }));
+    return parsed;
 };

package/dist/config/ghidraDisabledAnalyzers.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export const MAX_GHIDRA_DISABLED_ANALYZER_NAMES = 32;
+export const MAX_GHIDRA_DISABLED_ANALYZER_NAME_LENGTH = 120;
+// Ghidra's headless parser consumes `-`-prefixed arguments after a script path
+// as its own options, and REA joins the names with commas into one pre-script
+// argument, so a name can neither start with `-` nor contain a comma. The
+// remaining admitted characters keep the argument a single quotable token on
+// every supported launcher, including the Windows batch invocation.
+const ghidraAnalyzerNamePattern = /^[A-Za-z0-9][A-Za-z0-9 ._-]*$/u;
+/**
+ * Parse `REA_GHIDRA_DISABLED_ANALYZERS` into the Ghidra auto-analyzer names to
+ * disable before default auto-analysis, such as
+ * `Objective-C Message Analyzer`. Empty and blank entries are dropped; a list
+ * without names selects no override.
+ */
+export const ghidraDisabledAnalyzersSchema = z
+    .string()
+    .transform((value) => value
+    .split(",")
+    .map((name) => name.trim())
+    .filter((name) => name.length > 0))
+    .refine((names) => names.length <= MAX_GHIDRA_DISABLED_ANALYZER_NAMES, `must list at most ${MAX_GHIDRA_DISABLED_ANALYZER_NAMES} analyzer names`)
+    .refine((names) => names.every((name) => name.length <= MAX_GHIDRA_DISABLED_ANALYZER_NAME_LENGTH), `must keep every analyzer name at most ${MAX_GHIDRA_DISABLED_ANALYZER_NAME_LENGTH} characters`)
+    .refine((names) => names.every((name) => ghidraAnalyzerNamePattern.test(name)), "must be Ghidra analyzer names starting with a letter or digit and containing only letters, digits, spaces, periods, underscores, and hyphens")
+    .transform((names) => (names.length === 0 ? undefined : names));

package/dist/config/ghidraLanguageOverride.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+// Ghidra language IDs are four colon-separated fields; variants may contain
+// spaces ("x86:LE:16:Real Mode") but never leading or trailing whitespace.
+export const ghidraLanguageIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9_.+-]+:(?:LE|BE):[1-9]\d*:[A-Za-z0-9_.+-](?:[A-Za-z0-9_.+ -]*[A-Za-z0-9_.+-])?$/u, "must be a Ghidra language ID such as x86:LE:32:default");
+export const ghidraCompilerSpecIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9_.+-]+$/u, "must be a Ghidra compiler-spec ID such as default or borlandcpp");

package/dist/config/homeDirectory.js

@@ -1,12 +1,15 @@
 import { userInfo } from "node:os";
+const firstNonempty = (...values) => values.find((value) => value !== undefined && value.length > 0);
 /** Resolve the caller's selected home before consulting the host account. */
 export const homeDirectoryFromEnvironment = (environment, platform) => {
+    const windowsDriveHome = environment.HOMEDRIVE !== undefined &&
+        environment.HOMEDRIVE.length > 0 &&
+        environment.HOMEPATH !== undefined &&
+        environment.HOMEPATH.length > 0
+        ? `${environment.HOMEDRIVE}${environment.HOMEPATH}`
+        : undefined;
     const selected = platform === "win32"
-        ? (environment.USERPROFILE ??
-            (environment.HOMEDRIVE !== undefined &&
-                environment.HOMEPATH !== undefined
-                ? `${environment.HOMEDRIVE}${environment.HOMEPATH}`
-                : environment.HOME))
-        : (environment.HOME ?? environment.USERPROFILE);
+        ? firstNonempty(environment.USERPROFILE, windowsDriveHome, environment.HOME)
+        : firstNonempty(environment.HOME, environment.USERPROFILE);
     return selected ?? userInfo().homedir;
 };

package/dist/config/mcpInputSchemaProfile.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { ConfigurationError } from "../domain/configurationErrors.js";
+import { err, ok } from "../domain/result.js";
+// Moonshot's function-calling API rejects requests while any single tool
+// parameters schema exceeds its literal serialized size cap. Community
+// measurements bound the cap between ~13.7 KB (accepted) and ~15 KB
+// (rejected); 13 KiB leaves margin under the lower bound. See
+// https://github.com/morluto/rea/issues/1484 for the measured evidence.
+export const COMPACT_INPUT_SCHEMA_BUDGET_BYTES = 13 * 1024;
+export const mcpInputSchemaProfileSchema = z.enum(["full", "compact"]);
+/** Select the exact compact presentation budget shared by registration and identity. */
+export const compactPresentationForMcpInputSchemaProfile = (profile) => profile === "compact"
+    ? { budgetBytes: COMPACT_INPUT_SCHEMA_BUDGET_BYTES }
+    : undefined;
+const profileConstraint = 'REA_MCP_INPUT_SCHEMA_PROFILE must be "full" (default) or "compact". The compact profile advertises input schemas without nested annotation prose for providers that cap each tool schema\'s serialized size.';
+/** Parse the advertised input schema presentation selection. */
+export const parseMcpInputSchemaProfile = (value) => {
+    if (value === undefined)
+        return ok(undefined);
+    const parsed = mcpInputSchemaProfileSchema.safeParse(value);
+    return parsed.success
+        ? ok(parsed.data)
+        : err(new ConfigurationError(profileConstraint, {
+            settings: [
+                {
+                    setting: "REA_MCP_INPUT_SCHEMA_PROFILE",
+                    constraint: profileConstraint,
+                },
+            ],
+        }));
+};

package/dist/config/mcpOutputSchemaProfile.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ConfigurationError } from "../domain/configurationErrors.js";
+import { err, ok } from "../domain/result.js";
+/** Select whether tools/list carries the large output contracts. */
+export const mcpOutputSchemaProfileSchema = z.enum(["full", "off"]);
+const profileConstraint = 'REA_MCP_OUTPUT_SCHEMA_PROFILE must be "full" (default) or "off". The off profile omits output schemas from tools/list while REA validates every successful result against its canonical tool contract and returns complete structured content.';
+/** Parse the output schema advertisement selection at server composition. */
+export const parseMcpOutputSchemaProfile = (value) => {
+    if (value === undefined)
+        return ok(undefined);
+    const parsed = mcpOutputSchemaProfileSchema.safeParse(value);
+    return parsed.success
+        ? ok(parsed.data)
+        : err(new ConfigurationError(profileConstraint, {
+            settings: [
+                {
+                    setting: "REA_MCP_OUTPUT_SCHEMA_PROFILE",
+                    constraint: profileConstraint,
+                },
+            ],
+        }));
+};