rea-agents 3.0.0 → 3.2.0

package/dist/ghidra/GhidraInstallation.js

@@ -3,14 +3,14 @@ import { constants } from "node:fs";
 import { accessSync, readFileSync } from "node:fs";
 import { posix, win32 } from "node:path";
 /** Exact Ghidra build whose Java bridge contract this REA release supports. */
-export const SUPPORTED_GHIDRA_VERSION = "12.1.2";
+export const SUPPORTED_GHIDRA_VERSION = "12.1.4";
 /** Exact JDK major documented by the supported Ghidra release. */
 export const SUPPORTED_GHIDRA_JAVA_MAJOR = 21;
 /** Inspect an installation without importing a target or modifying Ghidra. */
 export const inspectGhidraInstallation = (options, host = systemGhidraInstallationHost()) => {
     const platform = options.platform ?? process.platform;
     const architecture = options.architecture ?? process.arch;
-    const coordinates = installationCoordinates(options, platform, host);
+    const coordinates = installationCoordinates(options, platform, architecture, host);
     const checks = installationChecks({
         coordinates,
         platform,
@@ -18,24 +18,49 @@ export const inspectGhidraInstallation = (options, host = systemGhidraInstallati
         javaHome: options.javaHome,
         host,
     });
-    const failed = checks.find(({ ok }) => !ok);
-    return {
-        available: failed === undefined,
+    const failed = checks.find((check) => check.status === "failed");
+    const observation = {
         platform,
         architecture,
-        installDir: coordinates.installDir,
-        analyzeHeadlessPath: coordinates.analyzeHeadlessPath,
         applicationPropertiesPath: coordinates.applicationPropertiesPath,
-        providerVersion: coordinates.providerVersion,
+        nativeDecompilerPath: coordinates.nativeDecompilerPath,
         javaCommand: coordinates.javaCommand,
-        javaHome: coordinates.java?.home ?? options.javaHome ?? null,
-        javaVersion: coordinates.java?.version ?? null,
         checks,
-        rejectionCode: failed?.code ?? null,
-        reason: failed?.remediation ?? null,
+    };
+    if (failed !== undefined)
+        return {
+            status: "unavailable",
+            ...observation,
+            installDir: coordinates.installDir,
+            analyzeHeadlessPath: coordinates.analyzeHeadlessPath,
+            providerVersion: coordinates.properties?.providerVersion ?? null,
+            javaHome: coordinates.java?.home ?? options.javaHome ?? null,
+            javaVersion: coordinates.java?.version ?? null,
+            rejection: { code: failed.code, reason: failed.remediation },
+        };
+    return availableInstallation(coordinates, observation);
+};
+const availableInstallation = (coordinates, observation) => {
+    const providerVersion = coordinates.properties?.providerVersion;
+    if (coordinates.installDir === null ||
+        coordinates.applicationPropertiesPath === null ||
+        coordinates.analyzeHeadlessPath === null ||
+        providerVersion === null ||
+        providerVersion === undefined ||
+        coordinates.java === undefined)
+        throw new TypeError("Passing Ghidra installation checks produced incomplete coordinates");
+    return {
+        status: "available",
+        ...observation,
+        installDir: coordinates.installDir,
+        analyzeHeadlessPath: coordinates.analyzeHeadlessPath,
+        applicationPropertiesPath: coordinates.applicationPropertiesPath,
+        providerVersion,
+        javaHome: coordinates.java.home,
+        javaVersion: coordinates.java.version,
     };
 };
-const installationCoordinates = (options, platform, host) => {
+const installationCoordinates = (options, platform, architecture, host) => {
     const path = platform === "win32" ? win32 : posix;
     const installDir = options.installDir ?? null;
     const applicationPropertiesPath = installDir === null
@@ -44,6 +69,17 @@ const installationCoordinates = (options, platform, host) => {
     const analyzeHeadlessPath = installDir === null
         ? null
         : path.join(installDir, "support", platform === "win32" ? "analyzeHeadless.bat" : "analyzeHeadless");
+    const decompilerPlatform = platform === "darwin"
+        ? architecture === "arm64"
+            ? "mac_arm_64"
+            : "mac_x86_64"
+        : null;
+    const nativeDecompilerPath = installDir === null || decompilerPlatform === null
+        ? null
+        : ([
+            path.join(installDir, "Ghidra", "Features", "Decompiler", "os", decompilerPlatform, "decompile"),
+            path.join(installDir, "Ghidra", "Features", "Decompiler", "build", "os", decompilerPlatform, "decompile"),
+        ].find((candidate) => host.executable(candidate)) ?? null);
     const properties = applicationPropertiesPath === null
         ? undefined
         : host.readText(applicationPropertiesPath);
@@ -56,10 +92,10 @@ const installationCoordinates = (options, platform, host) => {
         installDir,
         applicationPropertiesPath,
         analyzeHeadlessPath,
-        propertiesAvailable: properties !== undefined,
-        providerVersion: properties === undefined
-            ? null
-            : propertyValue(properties, "application.version"),
+        nativeDecompilerPath,
+        properties: properties === undefined
+            ? undefined
+            : { providerVersion: propertyValue(properties, "application.version") },
         javaCommand,
         java: host.probeJava(javaCommand, ghidraJavaEnvironment(options.javaHome, process.env, platform)),
     };
@@ -67,28 +103,28 @@ const installationCoordinates = (options, platform, host) => {
 const installationChecks = ({ coordinates, platform, architecture, javaHome, host, }) => [
     installationCheck({
         name: "configuration",
-        ok: coordinates.installDir !== null,
+        passed: coordinates.installDir !== null,
         code: "not_configured",
         detail: coordinates.installDir ?? "GHIDRA_INSTALL_DIR is not set",
-        remediation: "Set GHIDRA_INSTALL_DIR to an extracted Ghidra 12.1.2 release directory.",
+        remediation: "Set GHIDRA_INSTALL_DIR to an extracted Ghidra 12.1.4 release directory.",
     }),
     installationCheck({
         name: "platform",
-        ok: platform === "linux" || platform === "win32",
+        passed: platform === "linux" || platform === "win32",
         code: "unsupported_host",
         detail: platform,
-        remediation: "Use REA's Ghidra adapter on a supported Linux or Windows x64 host.",
+        remediation: "Use REA's Ghidra adapter on Linux or Windows x64.",
     }),
     installationCheck({
         name: "architecture",
-        ok: architecture === "x64",
+        passed: (platform === "linux" || platform === "win32") && architecture === "x64",
         code: "unsupported_host",
         detail: architecture,
-        remediation: "Use the official x86-64 Ghidra distribution on an x64 Linux or Windows host.",
+        remediation: "Use x64 on Linux or Windows.",
     }),
     installationCheck({
         name: "installation",
-        ok: coordinates.propertiesAvailable,
+        passed: coordinates.properties !== undefined,
         code: "executable_missing",
         detail: coordinates.applicationPropertiesPath ??
             "Ghidra application properties unavailable",
@@ -96,27 +132,39 @@ const installationChecks = ({ coordinates, platform, architecture, javaHome, hos
     }),
     installationCheck({
         name: "version",
-        ok: coordinates.providerVersion === SUPPORTED_GHIDRA_VERSION,
-        code: coordinates.providerVersion === null
+        passed: coordinates.properties?.providerVersion === SUPPORTED_GHIDRA_VERSION,
+        code: coordinates.properties?.providerVersion === null ||
+            coordinates.properties?.providerVersion === undefined
             ? "version_unresolved"
             : "unsupported_version",
-        detail: coordinates.providerVersion ?? "unknown",
+        detail: coordinates.properties?.providerVersion ?? "unknown",
         remediation: `Install Ghidra ${SUPPORTED_GHIDRA_VERSION}, or update REA for a different Ghidra build.`,
     }),
     installationCheck({
         name: "headless",
-        ok: coordinates.analyzeHeadlessPath !== null &&
+        passed: coordinates.analyzeHeadlessPath !== null &&
             host.executable(coordinates.analyzeHeadlessPath),
         code: "executable_missing",
         detail: coordinates.analyzeHeadlessPath ?? "analyzeHeadless unavailable",
         remediation: "Restore support/analyzeHeadless or support/analyzeHeadless.bat from the official Ghidra release.",
     }),
+    installationCheck({
+        name: "native_decompiler",
+        passed: platform !== "darwin" || coordinates.nativeDecompilerPath !== null,
+        code: "executable_missing",
+        detail: platform !== "darwin"
+            ? "not required on this platform"
+            : (coordinates.nativeDecompilerPath ??
+                "matching macOS native decompiler was not found"),
+        remediation: "REA does not build native tools. Build Ghidra's native components for this macOS architecture or provide an installation containing Ghidra/Features/Decompiler/os/<platform>/decompile.",
+    }),
     javaCheck(coordinates.java, coordinates.javaCommand, javaHome),
 ];
 /** Project an installation probe into caller-visible, secret-free diagnostics. */
 export const ghidraInstallationDiagnostics = (inspection) => ({
     install_dir: inspection.installDir,
     analyze_headless_path: inspection.analyzeHeadlessPath,
+    native_decompiler_path: inspection.nativeDecompilerPath,
     application_properties_path: inspection.applicationPropertiesPath,
     provider_version: inspection.providerVersion,
     java_command: inspection.javaCommand,
@@ -126,8 +174,8 @@ export const ghidraInstallationDiagnostics = (inspection) => ({
     architecture: inspection.architecture,
     checks: inspection.checks.map((check) => ({
         name: check.name,
-        ok: check.ok,
-        code: check.code,
+        ok: check.status === "passed",
+        code: check.status === "failed" ? check.code : null,
         detail: check.detail,
     })),
 });
@@ -148,24 +196,30 @@ export const ghidraJavaEnvironment = (javaHome, environment = process.env, platf
             PATH: `${(platform === "win32" ? win32 : posix).join(javaHome, "bin")}${platform === "win32" ? win32.delimiter : posix.delimiter}${environment.PATH ?? ""}`,
         };
 };
-const installationCheck = (options) => ({
-    name: options.name,
-    ok: options.ok,
-    code: options.ok ? null : options.code,
-    detail: options.detail,
-    remediation: options.ok ? null : options.remediation,
-});
+const installationCheck = (options) => options.passed
+    ? {
+        status: "passed",
+        name: options.name,
+        detail: options.detail,
+    }
+    : {
+        status: "failed",
+        name: options.name,
+        code: options.code,
+        detail: options.detail,
+        remediation: options.remediation,
+    };
 const javaCheck = (observation, command, configuredHome) => {
     const supported = observation !== undefined &&
         observation.major === SUPPORTED_GHIDRA_JAVA_MAJOR &&
         observation.bits === 64 &&
-        observation.jdk;
+        observation.runtime === "jdk";
     const detail = observation === undefined
         ? command
-        : `${observation.version}; ${String(observation.bits)}-bit; ${observation.jdk ? "JDK" : "runtime only"}; ${observation.home}`;
+        : `${observation.version}; ${String(observation.bits)}-bit; ${observation.runtime === "jdk" ? "JDK" : "runtime only"}; ${observation.home}`;
     return installationCheck({
         name: "java",
-        ok: supported,
+        passed: supported,
         code: observation === undefined ? "runtime_missing" : "unsupported_version",
         detail,
         remediation: configuredHome === undefined
@@ -206,7 +260,7 @@ const systemGhidraInstallationHost = () => ({
             encoding: "utf8",
             env: environment,
             timeout: 5_000,
-            maxBuffer: 128 * 1024,
+            maxBuffer: Number.POSITIVE_INFINITY,
             windowsHide: true,
         });
         if (observed.error !== undefined || observed.status !== 0)
@@ -222,7 +276,9 @@ const systemGhidraInstallationHost = () => ({
             major: javaMajor(version),
             home,
             bits,
-            jdk: executablePath((process.platform === "win32" ? win32 : posix).join(home, "bin", process.platform === "win32" ? "javac.exe" : "javac")),
+            runtime: executablePath((process.platform === "win32" ? win32 : posix).join(home, "bin", process.platform === "win32" ? "javac.exe" : "javac"))
+                ? "jdk"
+                : "jre",
         };
     },
 });

package/dist/ghidra/GhidraInventoryValues.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
-/** Read-only direct operations admitted by the Ghidra v1 adapter. */
+/** Read-only direct inventory operations admitted by the Ghidra adapter. */
 export const GHIDRA_INVENTORY_OPERATIONS = [
     "address_name",
     "list_documents",
@@ -18,37 +17,25 @@ export const GHIDRA_INVENTORY_OPERATIONS = [
 const operationSet = new Set(GHIDRA_INVENTORY_OPERATIONS);
 /** Narrow an application operation to the Ghidra inventory surface. */
 export const isGhidraInventoryOperation = (operation) => operationSet.has(operation);
-export const ghidraBoundedIdentifierSchema = z.string().min(1).max(4096);
-const boundedIdentifier = ghidraBoundedIdentifierSchema;
-const document = boundedIdentifier.nullable().default(null);
-const explicitAddress = boundedIdentifier;
+export const ghidraIdentifierSchema = z.string().min(1);
+const identifier = ghidraIdentifierSchema;
+const document = identifier.nullable().default(null);
+const explicitAddress = identifier;
 const filteredAddress = explicitAddress.nullable().default(null);
-const pagination = {
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(500).default(100),
-};
 const searchInput = {
-    pattern: z.string().min(1).max(256),
+    pattern: z.string().min(1),
     mode: z.enum(["literal", "regex"]).default("literal"),
     case_sensitive: z.boolean().default(false),
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(100).default(100),
     document,
 };
 const inputSchemas = {
     address_name: z.object({ document, address: explicitAddress }).strict(),
     list_documents: z.object({}).strict(),
-    list_names: z
-        .object({ document, address: filteredAddress, ...pagination })
-        .strict(),
-    list_procedures: z.object({ document, ...pagination }).strict(),
+    list_names: z.object({ document, address: filteredAddress }).strict(),
+    list_procedures: z.object({ document }).strict(),
     list_segments: z.object({ document }).strict(),
-    list_strings: z
-        .object({ document, address: filteredAddress, ...pagination })
-        .strict(),
-    procedure_address: z
-        .object({ document, procedure: boundedIdentifier })
-        .strict(),
+    list_strings: z.object({ document, address: filteredAddress }).strict(),
+    procedure_address: z.object({ document, procedure: identifier }).strict(),
     resolve_containing_procedure: z
         .object({ document, address: explicitAddress })
         .strict(),
@@ -60,13 +47,12 @@ export const parseGhidraInventoryInput = (operation, value) => {
     const parsed = inputSchemas[operation].safeParse(value);
     if (!parsed.success)
         return err(new AnalysisInputError(operation, { cause: parsed.error }));
-    return ok(jsonObjectSchema.parse(parsed.data));
+    return ok(parsed.data);
 };
 export const ghidraCanonicalAddressSchema = z
     .string()
     .regex(/^(?:0x[0-9a-f]+|(?:[A-Za-z0-9._~-]|%[0-9A-F]{2})+:0x[0-9a-f]+)$/u);
 const canonicalAddress = ghidraCanonicalAddressSchema;
-const valueTruncation = { value_truncated: z.boolean() };
 const symbolFacts = z
     .object({
     primary: z.boolean(),
@@ -96,7 +82,6 @@ const stringFacts = z
 const baseItem = {
     address: canonicalAddress,
     value: z.string(),
-    ...valueTruncation,
 };
 const symbolItem = z.object({ ...baseItem, symbol: symbolFacts }).strict();
 const procedureItem = z
@@ -104,50 +89,6 @@ const procedureItem = z
     .strict();
 const stringItem = z.object({ ...baseItem, string: stringFacts }).strict();
 const searchItem = z.object(baseItem).strict();
-const pageSchema = (item, maximumLimit) => z
-    .object({
-    items: z.array(item),
-    offset: z.number().int().min(0),
-    limit: z.number().int().min(1).max(maximumLimit),
-    total: z.number().int().min(0),
-    next_offset: z.number().int().min(0).nullable(),
-    has_more: z.boolean(),
-})
-    .strict()
-    .superRefine((page, context) => {
-    const next = page.offset + page.items.length;
-    const hasMore = next < page.total;
-    if (page.items.length > page.limit)
-        context.addIssue({
-            code: "custom",
-            path: ["items"],
-            message: "page exceeds its declared limit",
-        });
-    if (page.items.length > 0 && next > page.total)
-        context.addIssue({
-            code: "custom",
-            path: ["total"],
-            message: "page items exceed its exact total",
-        });
-    if (hasMore && page.items.length === 0)
-        context.addIssue({
-            code: "custom",
-            path: ["items"],
-            message: "page continuation must advance its offset",
-        });
-    if (page.has_more !== hasMore)
-        context.addIssue({
-            code: "custom",
-            path: ["has_more"],
-            message: "page continuation does not match its exact total",
-        });
-    if (page.next_offset !== (hasMore ? next : null))
-        context.addIssue({
-            code: "custom",
-            path: ["next_offset"],
-            message: "page continuation offset is inconsistent",
-        });
-});
 const availablePermissions = z
     .object({
     available: z.literal(true),
@@ -199,19 +140,19 @@ const containingProcedure = z.discriminatedUnion("found", [
 const resultSchemas = {
     address_name: z.string().nullable(),
     list_documents: z.array(z.string().min(1)).length(1),
-    list_names: pageSchema(symbolItem, 500),
-    list_procedures: pageSchema(procedureItem, 500),
+    list_names: z.array(symbolItem),
+    list_procedures: z.array(procedureItem),
     list_segments: z.array(segment),
-    list_strings: pageSchema(stringItem, 500),
+    list_strings: z.array(stringItem),
     procedure_address: canonicalAddress,
     resolve_containing_procedure: containingProcedure,
-    search_procedures: pageSchema(searchItem, 100),
-    search_strings: pageSchema(searchItem, 100),
+    search_procedures: z.array(searchItem),
+    search_strings: z.array(searchItem),
 };
-/** Require exact, bounded Java-bridge output before creating Evidence. */
+/** Validate exact Java-bridge output before creating Evidence. */
 export const parseGhidraInventoryResult = (operation, value) => {
     const parsed = resultSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(jsonValueSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisOutputError(operation, "Ghidra bridge output did not match the inventory contract", { cause: parsed.error }));
 };

package/dist/ghidra/GhidraLauncher.js

@@ -5,7 +5,6 @@ import { AnalysisCancelledError } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { cleanupOwnedProcessGroup, cleanupWindowsProcessTree, } from "../process/ProcessOwnership.js";
 import { spawnOwnedProviderProcess, } from "../process/ProviderProcess.js";
-import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, GHIDRA_MAX_CPU, GHIDRA_MAX_HEAP, } from "./GhidraDefaults.js";
 import { ghidraJavaEnvironment } from "./GhidraInstallation.js";
 /** Local launch failure retained as the cause of a provider-neutral error. */
 export class GhidraLaunchError extends Error {
@@ -36,7 +35,6 @@ export class GhidraHeadlessLauncher {
                 paths.dataRoot,
             ].map((path) => mkdir(path, { recursive: true, mode: 0o700 })));
             await writeFileAtomic(paths.descriptorPath, `${JSON.stringify({
-                schema_version: 2,
                 transport: session.transport,
                 endpoint_path: session.endpointPath,
                 token: session.token,
@@ -74,7 +72,6 @@ export class GhidraHeadlessLauncher {
                 env: ghidraLaunchEnvironment(paths, this.options.javaHome, platform),
             });
             await writeFileAtomic(paths.ownershipPath, `${JSON.stringify({
-                schema_version: 1,
                 run_id: session.runId,
                 pid: started.ownership.leaderPid,
                 process_group_id: started.ownership.processGroupId,
@@ -156,10 +153,6 @@ export const ghidraHeadlessArguments = (options) => [
     options.targetPath,
     "-readOnly",
     "-deleteProject",
-    "-analysisTimeoutPerFile",
-    String(GHIDRA_ANALYSIS_TIMEOUT_SECONDS),
-    "-max-cpu",
-    String(GHIDRA_MAX_CPU),
     "-log",
     options.ghidraLogPath,
     "-scriptlog",
@@ -200,7 +193,6 @@ const ghidraLaunchEnvironment = (paths, javaHome, platform) => {
         XDG_CACHE_HOME: paths.cacheRoot,
         XDG_CONFIG_HOME: paths.configRoot,
         XDG_DATA_HOME: paths.dataRoot,
-        GHIDRA_HEADLESS_MAXMEM: GHIDRA_MAX_HEAP,
         GHIDRA_HEADLESS_JAVA_OPTIONS: javaOptions,
     };
 };

package/dist/ghidra/GhidraProvider.js

@@ -1,18 +1,19 @@
 import { fileURLToPath } from "node:url";
 import { createAnalysisExecution, } from "../application/AnalysisProvider.js";
+import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisTimeoutError, ProviderAdapterError, } from "../domain/errors.js";
 import { err, ok } from "../domain/result.js";
 import { GhidraClient } from "./GhidraClient.js";
-import { GHIDRA_ANALYSIS_TIMEOUT_SECONDS, GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, GHIDRA_DECOMPILE_TIMEOUT_SECONDS, GHIDRA_STARTUP_TIMEOUT_MS, } from "./GhidraDefaults.js";
+import { GHIDRA_STARTUP_TIMEOUT_MS } from "./GhidraDefaults.js";
 import { isGhidraFunctionOperation, parseGhidraFunctionInput, parseGhidraFunctionResult, } from "./GhidraFunctionValues.js";
 import { isGhidraInventoryOperation, parseGhidraInventoryInput, parseGhidraInventoryResult, } from "./GhidraInventoryValues.js";
 import { ghidraInstallationDiagnostics, inspectGhidraInstallation, } from "./GhidraInstallation.js";
 import { GhidraHeadlessLauncher } from "./GhidraLauncher.js";
 import { resolveGhidraAnalysisProfile } from "./GhidraAnalysisProfile.js";
 import { CAPABILITIES, WINDOWS_P0_CAPABILITIES, GHIDRA_PROVIDER_IDENTITY, GHIDRA_PROVIDER_TOOL_CONTRACTS, healthLimitations, windowsP0Limitations, limitationsFor, } from "./GhidraProviderCapabilities.js";
+import { WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON, hasWindowsNativeAuthority, windowsNativeCapabilities, } from "../process/WindowsAuthority.js";
 export { GHIDRA_PROVIDER_IDENTITY, GHIDRA_PROVIDER_TOOL_CONTRACTS };
 const SUPPORTED_ARCHITECTURES = new Set(["x86", "x86_64", "arm", "arm64"]);
-const SUPPORTED_FORMATS = new Set(["elf", "pe", "mach-o"]);
 /** Ghidra candidate backed by an isolated read-only headless import. */
 export class GhidraProvider {
     config;
@@ -37,7 +38,19 @@ export class GhidraProvider {
     inspectAvailability() {
         const installation = this.#inspectInstallation();
         const diagnostics = ghidraInstallationDiagnostics(installation);
-        return installation.available
+        if (installation.status === "available" &&
+            installation.platform === "win32" &&
+            !hasWindowsNativeAuthority(installation.platform))
+            return {
+                status: "unavailable",
+                code: "unsupported_host",
+                reason: WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON,
+                diagnostics: {
+                    ...diagnostics,
+                    windows_security: jsonObjectSchema.parse(windowsNativeCapabilities(installation.platform)),
+                },
+            };
+        return installation.status === "available"
             ? {
                 status: "available",
                 code: null,
@@ -46,8 +59,8 @@ export class GhidraProvider {
             }
             : {
                 status: "unavailable",
-                code: installation.rejectionCode ?? "not_configured",
-                reason: installation.reason ?? "Ghidra installation is not available.",
+                code: installation.rejection.code,
+                reason: installation.rejection.reason,
                 diagnostics,
             };
     }
@@ -70,15 +83,7 @@ export class GhidraProvider {
             };
         if (hostPlatform === "win32")
             return inspectWindowsP0TargetSupport(target, diagnostics);
-        if (!SUPPORTED_FORMATS.has(target.format))
-            return {
-                status: "unsupported",
-                code: "target_format_unsupported",
-                reason: `Ghidra v1 does not import ${target.format} through this adapter.`,
-                diagnostics,
-            };
-        if (target.architecture === undefined ||
-            !SUPPORTED_ARCHITECTURES.has(target.architecture))
+        if (!SUPPORTED_ARCHITECTURES.has(target.architecture))
             return {
                 status: "unsupported",
                 code: "architecture_unsupported",
@@ -101,7 +106,13 @@ export class GhidraProvider {
         if (!prerequisites.ok)
             return unavailableClient(prerequisites.error);
         const committedProfile = prerequisites.value.profile;
-        const providerLimitations = installation.platform === "win32" ? windowsP0Limitations : [];
+        const providerLimitations = installation.platform === "win32"
+            ? windowsP0Limitations
+            : installation.platform === "darwin"
+                ? [
+                    "macOS sessions require a matching executable Ghidra native decompiler; REA checks for it but does not build native components or change Gatekeeper quarantine state.",
+                ]
+                : [];
         const client = this.clientFactory({
             launcher: new GhidraHeadlessLauncher({
                 analyzeHeadlessPath: prerequisites.value.analyzeHeadlessPath,
@@ -141,13 +152,7 @@ export class GhidraProvider {
                     : parseGhidraInventoryInput(operation, parameters);
                 if (!input.ok)
                     return input;
-                const called = await client.callTool(operation, input.value, {
-                    ...(options?.signal === undefined ? {} : { signal: options.signal }),
-                    ...(operation === "procedure_pseudo_code" ||
-                        operation === "analyze_function"
-                        ? { timeoutMs: GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS }
-                        : {}),
-                });
+                const called = await client.callTool(operation, input.value, options?.signal === undefined ? {} : { signal: options.signal });
                 if (!called.ok)
                     return err(projectSessionError(operation, called.error));
                 const result = isGhidraFunctionOperation(operation)
@@ -231,12 +236,13 @@ const inspectWindowsP0TargetSupport = (target, diagnostics) => {
 const ghidraClientPrerequisites = (target, profile, installation) => {
     if (target.kind !== "executable")
         return err(new AnalysisCapabilityUnavailableError("ghidra", "health", `Ghidra cannot import ${target.kind} targets through this adapter.`));
-    if (!installation.available ||
-        installation.analyzeHeadlessPath === null ||
-        installation.providerVersion === null)
+    if (installation.status === "unavailable")
         return err(new ProviderAdapterError("ghidra", "health", {
             diagnostics: ghidraInstallationDiagnostics(installation),
         }));
+    if (installation.platform === "win32" &&
+        !hasWindowsNativeAuthority(installation.platform))
+        return err(new AnalysisCapabilityUnavailableError("ghidra", "health", WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON));
     if (profile === undefined || profile.provider.id !== "ghidra")
         return err(new ProviderAdapterError("ghidra", "health"));
     return ok({
@@ -253,12 +259,7 @@ const projectSessionError = (operation, failure) => {
     if (failure.kind === "cancelled")
         return new AnalysisCancelledError(operation);
     if (failure.kind === "timeout" || failure.kind === "analysis_timeout")
-        return new AnalysisTimeoutError(operation, failure.timeoutMs ??
-            (failure.kind === "analysis_timeout"
-                ? GHIDRA_ANALYSIS_TIMEOUT_SECONDS * 1_000
-                : GHIDRA_STARTUP_TIMEOUT_MS));
-    if (failure.kind === "remote" && failure.remoteCode === "decompile_timeout")
-        return new AnalysisTimeoutError(operation, GHIDRA_DECOMPILE_TIMEOUT_SECONDS * 1_000);
+        return new AnalysisTimeoutError(operation, failure.timeoutMs ?? GHIDRA_STARTUP_TIMEOUT_MS);
     if (failure.kind === "remote" && failure.remoteCode === "decompile_cancelled")
         return new AnalysisCancelledError(operation);
     if (failure.kind === "remote" &&