rea-agents 6.3.0 → 6.4.0

package/dist/ghidra/GhidraLanguageCatalog.js

@@ -0,0 +1,99 @@
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DOMParser, onWarningStopParsing } from "@xmldom/xmldom";
+import { ConfigurationError } from "../domain/configurationErrors.js";
+// Language definitions are small XML files; refuse anything implausibly large.
+const MAX_LDEFS_BYTES = 4 * 1024 * 1024;
+// Processor modules ship under Processors; installed extensions may add more.
+const LANGUAGE_ROOTS = ["Ghidra/Processors", "Ghidra/Extensions"];
+/** Parse the `<language>` elements of one `.ldefs` document. */
+export const parseGhidraLanguageDefinitions = (text) => {
+    const definitions = [];
+    const document = new DOMParser({
+        onError: onWarningStopParsing,
+    }).parseFromString(text, "application/xml");
+    const root = document.documentElement;
+    if (root?.tagName !== "language_definitions")
+        throw new SyntaxError("Expected Ghidra language_definitions XML root");
+    for (const language of Array.from(root.getElementsByTagName("language"))) {
+        if (language.parentNode !== root)
+            continue;
+        const id = language.getAttribute("id");
+        if (id === null)
+            continue;
+        const compilerSpecIds = [];
+        for (const compiler of Array.from(language.getElementsByTagName("compiler"))) {
+            if (compiler.parentNode !== language)
+                continue;
+            const compilerId = compiler.getAttribute("id");
+            if (compilerId !== null)
+                compilerSpecIds.push(compilerId);
+        }
+        definitions.push({ id, compilerSpecIds });
+    }
+    return definitions;
+};
+const languageDirectories = async (installDir) => {
+    const directories = [];
+    for (const root of LANGUAGE_ROOTS) {
+        let modules;
+        try {
+            modules = await readdir(join(installDir, root));
+        }
+        catch {
+            continue;
+        }
+        for (const module of modules.sort())
+            directories.push(join(installDir, root, module, "data", "languages"));
+    }
+    return directories;
+};
+/** Read every language definition shipped by one Ghidra installation. */
+export const readGhidraLanguageCatalog = async (installDir) => {
+    const definitions = [];
+    for (const directory of await languageDirectories(installDir)) {
+        let entries;
+        try {
+            entries = await readdir(directory);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries.sort()) {
+            if (!entry.endsWith(".ldefs"))
+                continue;
+            const bytes = await readFile(join(directory, entry));
+            if (bytes.length > MAX_LDEFS_BYTES)
+                continue;
+            definitions.push(...parseGhidraLanguageDefinitions(bytes.toString("utf8")));
+        }
+    }
+    return definitions;
+};
+/**
+ * Check a configured import language against the installation before launch,
+ * so an unknown ID fails as configuration instead of as a failed import.
+ */
+export const admitGhidraLanguageOverride = (override, catalog, providerVersion) => {
+    const language = catalog.find((value) => value.id === override.languageId);
+    if (language === undefined)
+        return new ConfigurationError("Invalid REA environment configuration", {
+            settings: [
+                {
+                    setting: "REA_GHIDRA_LANGUAGE_ID",
+                    constraint: `is not a language defined by Ghidra ${providerVersion}`,
+                },
+            ],
+        });
+    if (override.compilerSpecId !== undefined &&
+        !language.compilerSpecIds.includes(override.compilerSpecId))
+        return new ConfigurationError("Invalid REA environment configuration", {
+            settings: [
+                {
+                    setting: "REA_GHIDRA_COMPILER_SPEC_ID",
+                    constraint: `must be one of the selected language's compiler specs: ${language.compilerSpecIds.join(", ")}`,
+                },
+            ],
+        });
+    return null;
+};

package/dist/ghidra/GhidraLauncher.js

@@ -1,6 +1,7 @@
+import { GHIDRA_SEED_SCRIPT, snapshotGhidraAnalysisSeeds, } from "./GhidraAnalysisSeeds.js";
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { mkdir } from "node:fs/promises";
-import { basename, dirname, join, win32 } from "node:path";
+import { basename, dirname, join, posix, win32 } from "node:path";
 import writeFileAtomic from "write-file-atomic";
 import { windowsPrivateRuntime } from "../windows/WindowsPrivateRuntime.js";
 import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
@@ -41,6 +42,9 @@ export class GhidraHeadlessLauncher {
         let started;
         try {
             await createGhidraRuntimeDirectories(paths, platform);
+            const seedPath = this.options.analysisSeeds === undefined
+                ? undefined
+                : await snapshotGhidraAnalysisSeeds(this.options.analysisSeeds, session.runtimeRoot);
             const extensions = await snapshotGhidraExtensions(this.options.analysisExtensions ?? [], session.runtimeRoot);
             await writeGhidraRuntimeFile(paths.descriptorPath, `${JSON.stringify({
                 transport: session.transport,
@@ -57,6 +61,7 @@ export class GhidraHeadlessLauncher {
             if (isAborted(options.signal))
                 return err(new AnalysisCancelledError("open_binary"));
             const headlessArguments = ghidraHeadlessArguments({
+                platform,
                 projectRoot: paths.projectRoot,
                 targetPath: session.targetPath,
                 bridgeScriptPath: this.options.bridgeScriptPath,
@@ -69,6 +74,10 @@ export class GhidraHeadlessLauncher {
                 ...(this.options.dosMz === undefined
                     ? {}
                     : { dosMz: this.options.dosMz }),
+                ...(this.options.languageOverride === undefined
+                    ? {}
+                    : { languageOverride: this.options.languageOverride }),
+                ...(seedPath === undefined ? {} : { seedPath }),
             });
             const scriptCommand = ghidraHeadlessCommand({
                 environment: this.options.environment,
@@ -209,52 +218,84 @@ const cleanupStartedProcess = (started, platform) => started.cleanup !== undefin
         ? cleanupWindowsProcessTree(started.ownership.leaderPid)
         : cleanupOwnedProcessGroup(started.ownership);
 /** Build the complete read-only headless invocation in deterministic order. */
-export const ghidraHeadlessArguments = (options) => [
-    options.projectRoot,
-    "rea-project",
-    "-import",
-    options.targetPath,
-    ...(options.dosMz === true
-        ? [
-            "-loader",
-            "MzLoader",
-            "-processor",
-            "x86:LE:16:Real Mode",
-            "-cspec",
-            "default",
-        ]
-        : options.dosCom === true
+export const ghidraHeadlessArguments = (options) => {
+    // Bridge script paths use the target platform's syntax, which differs from
+    // the host when building a cross-platform invocation.
+    const scriptPath = (options.platform ?? process.platform) === "win32" ? win32 : posix;
+    const bridgeDirectory = scriptPath.dirname(options.bridgeScriptPath);
+    const override = options.languageOverride;
+    if (override !== undefined &&
+        (options.dosMz === true || options.dosCom === true))
+        throw new Error("A Ghidra language override cannot be combined with a DOS import.");
+    return [
+        options.projectRoot,
+        "rea-project",
+        "-import",
+        options.targetPath,
+        ...(options.dosMz === true
             ? [
                 "-loader",
-                "BinaryLoader",
-                "-loader-baseAddr",
-                "1000:0100",
+                "MzLoader",
                 "-processor",
                 "x86:LE:16:Real Mode",
                 "-cspec",
                 "default",
             ]
+            : options.dosCom === true
+                ? [
+                    "-loader",
+                    "BinaryLoader",
+                    "-loader-baseAddr",
+                    "1000:0100",
+                    "-processor",
+                    "x86:LE:16:Real Mode",
+                    "-cspec",
+                    "default",
+                ]
+                : override !== undefined
+                    ? [
+                        "-processor",
+                        override.languageId,
+                        ...(override.compilerSpecId === undefined
+                            ? []
+                            : ["-cspec", override.compilerSpecId]),
+                    ]
+                    : []),
+        "-readOnly",
+        "-deleteProject",
+        "-log",
+        options.ghidraLogPath,
+        "-scriptlog",
+        options.scriptLogPath,
+        "-scriptPath",
+        bridgeDirectory,
+        ...(options.dosCom === true
+            ? [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraPrepareCom.java"),
+            ]
             : []),
-    "-readOnly",
-    "-deleteProject",
-    "-log",
-    options.ghidraLogPath,
-    "-scriptlog",
-    options.scriptLogPath,
-    "-scriptPath",
-    dirname(options.bridgeScriptPath),
-    ...(options.dosCom === true
-        ? [
-            "-preScript",
-            join(dirname(options.bridgeScriptPath), "ReaGhidraPrepareCom.java"),
-        ]
-        : []),
-    "-postScript",
-    // Ghidra checks the caller's cwd before scriptPath for a basename. Select
-    // the packaged source explicitly so unrelated entries cannot shadow it.
-    options.bridgeScriptPath,
-    options.descriptorPath,
-];
+        // Seeds follow any loader preparation and precede default auto-analysis.
+        ...(options.seedPath === undefined
+            ? []
+            : [
+                "-preScript",
+                scriptPath.join(bridgeDirectory, GHIDRA_SEED_SCRIPT),
+                options.seedPath,
+            ]),
+        ...((options.platform ?? process.platform) === "win32"
+            ? []
+            : [
+                "-postScript",
+                scriptPath.join(bridgeDirectory, "ReaGhidraNoReturnFix.java"),
+            ]),
+        "-postScript",
+        // Ghidra checks the caller's cwd before scriptPath for a basename. Select
+        // the packaged source explicitly so unrelated entries cannot shadow it.
+        options.bridgeScriptPath,
+        options.descriptorPath,
+    ];
+};
 const ghidraRuntimePaths = (runtimeRoot) => ({
     projectRoot: join(runtimeRoot, "project"),
     homeRoot: join(runtimeRoot, "home"),

package/dist/ghidra/GhidraLoadImageAttest.js

@@ -1,11 +1,52 @@
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { nativeLoadImageObservationSchema, nativeLoadImageSchema, } from "../domain/native/nativeLoadImage.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { err, ok } from "../domain/result.js";
 import { attestGhidraDosComLoadImage, attestGhidraDosLoadImage, } from "./GhidraLoadImageValues.js";
+import {} from "../domain/native/nativeAotPe.js";
+const isSignalAborted = (signal) => signal?.aborted === true;
 /** Independently verify measured load-image observations for admitted DOS targets. */
-export const attestGhidraNativeLoadImage = async (target, operation, measured, client, mapSessionError) => {
+export const attestGhidraNativeLoadImage = async (input) => {
+    const { target, operation, measured, client, mapSessionError, nativeAotResult, signal, } = input;
+    if (isSignalAborted(signal))
+        return err(new AnalysisCancelledError(operation));
     const observations = nativeLoadImageObservationSchema.parse(measured);
+    if (target.format === "pe") {
+        if (nativeAotResult === undefined)
+            return err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: {
+                    reason: "The Ghidra provider did not produce read-only NativeAOT metadata for this admitted PE snapshot.",
+                },
+            }));
+        if (isSignalAborted(signal))
+            return err(new AnalysisCancelledError(operation));
+        try {
+            return ok(jsonValueSchema.parse(nativeLoadImageSchema.parse({
+                status: "unsupported",
+                reason: "Independent load-image verification currently supports DOS MZ and explicit DOS COM targets only.",
+                observations: {
+                    ...observations,
+                    metadata_recovery: [
+                        ...(observations.metadata_recovery ?? []),
+                        nativeAotResult.summary,
+                    ],
+                },
+                limitations: [
+                    "Load-image verification is not performed for PE targets; NativeAOT metadata observations are derived separately from the exact admitted snapshot.",
+                ],
+            })));
+        }
+        catch (cause) {
+            return err(new ProviderAdapterError("ghidra", operation, {
+                diagnostics: {
+                    reason: cause instanceof Error
+                        ? cause.message
+                        : "NativeAOT metadata could not be represented in the load-image result",
+                },
+            }));
+        }
+    }
     if (target.format !== "dos-mz" && target.format !== "dos-com") {
         return ok(jsonValueSchema.parse(nativeLoadImageSchema.parse({
             status: "unsupported",
@@ -25,9 +66,15 @@ export const attestGhidraNativeLoadImage = async (target, operation, measured, c
     const snapshot = await client.readTargetSnapshot();
     if (!snapshot.ok)
         return err(mapSessionError(snapshot.error));
+    if (snapshot.value.kind !== "captured")
+        return err(new ProviderAdapterError("ghidra", operation, {
+            diagnostics: {
+                reason: "The uncapped DOS load-image snapshot was unexpectedly not captured.",
+            },
+        }));
     const attested = (target.format === "dos-com"
         ? attestGhidraDosComLoadImage
-        : attestGhidraDosLoadImage)(snapshot.value, target.sha256 ?? "", observations);
+        : attestGhidraDosLoadImage)(snapshot.value.bytes, target.sha256 ?? "", observations);
     if (!attested.ok)
         return err(new ProviderAdapterError("ghidra", operation, {
             diagnostics: { reason: attested.error },

package/dist/ghidra/GhidraMipsProfile.js

@@ -0,0 +1,79 @@
+/** Keep family recognition separate from the deliberately bounded Ghidra lane. */
+export const ghidraMipsUnsupportedReason = (target) => {
+    if (target.kind !== "executable" || target.architecture !== "mips")
+        return null;
+    const metadata = target.mips;
+    if (target.format !== "elf" || metadata === undefined)
+        return "MIPS analysis requires ELF header metadata; a family name alone does not select an ISA or ABI.";
+    if (metadata.elfClass !== 32)
+        return "This Ghidra MIPS lane supports ELF32 only; MIPS64 and n64 remain unsupported.";
+    if (metadata.type !== 2)
+        return "This Ghidra MIPS lane supports ET_EXEC only; relocatable objects, shared images and PSP PRX need separate load verification.";
+    if ((metadata.flags & 0x0f000000) !== 0)
+        return "MIPS16, microMIPS and other ASE encodings are outside this standard-instruction MIPS lane.";
+    if ((metadata.flags & 0x00ff0000) !== 0)
+        return "Machine-specific MIPS variants, including PSP Allegrex, need a separately supported processor profile.";
+    if ((metadata.flags & 0xf0000000) !== 0x70000000)
+        return "This Ghidra MIPS lane requires EF_MIPS_ARCH_32R2; other ISA revisions need separate verification.";
+    if ((metadata.flags & 0x0000f000) !== 0x00001000 ||
+        (metadata.flags & 0x20) !== 0)
+        return "This Ghidra MIPS lane requires an explicit o32 ABI; unspecified, n32 and EABI targets remain unsupported.";
+    if ((metadata.flags & 0x00000200) !== 0)
+        return "EF_MIPS_FP64 requires separate verification of 64-bit floating-point register semantics in this Ghidra lane.";
+    if ((metadata.flags & 0x00000400) !== 0)
+        return "EF_MIPS_NAN2008 requires separate verification of NaN encoding semantics in this Ghidra lane.";
+    const abi = metadata.abiFlags;
+    if (abi === undefined || abi === null)
+        return [
+            "This Ghidra MIPS lane requires an inspected ABI flags record; header flags alone do not establish the floating-point ABI.",
+            ...(metadata.limitations ?? []),
+        ].join(" ");
+    if (abi.version !== 0)
+        return "This Ghidra MIPS lane requires ABI flags version 0; newer record semantics are unsupported.";
+    if (abi.isaLevel !== 32 || abi.isaRevision !== 2)
+        return "MIPS ABI flags must agree with the declared MIPS32r2 ISA.";
+    if (abi.gprSize !== 1 || abi.cpr1Size !== 1 || abi.cpr2Size !== 0)
+        return "This Ghidra MIPS lane requires 32-bit GPR/CPR1 and no CPR2; other register modes need separate verification.";
+    if (abi.fpAbi !== 1 && abi.fpAbi !== 5)
+        return "This Ghidra MIPS lane admits double-precision or FPXX ABI declarations only; soft-float, FP64 and unspecified modes need separate verification.";
+    if (abi.isaExtension !== 0 || abi.ases !== 0)
+        return "MIPS ABI flags declare an ISA extension or ASE outside this standard-instruction lane.";
+    if ((abi.flags1 & ~1) !== 0 || abi.flags2 !== 0)
+        return "MIPS ABI flags contain unsupported general flags.";
+    return null;
+};
+/** Commit source ELF interpretation without confusing target ISA with host CPU. */
+export const ghidraMipsProfileParameters = (target) => {
+    if (target.kind !== "executable" ||
+        target.architecture !== "mips" ||
+        target.mips === undefined)
+        return {};
+    const abi = target.mips.abiFlags;
+    return {
+        mips_elf: {
+            elf_class: target.mips.elfClass,
+            byte_order: target.mips.byteOrder,
+            type: target.mips.type,
+            flags: target.mips.flags,
+            ...(target.mips.limitations === undefined
+                ? {}
+                : { abi_flags_limitations: [...target.mips.limitations] }),
+            abi_flags: abi === undefined || abi === null
+                ? null
+                : {
+                    version: abi.version,
+                    isa_level: abi.isaLevel,
+                    isa_revision: abi.isaRevision,
+                    gpr_size: abi.gprSize,
+                    cpr1_size: abi.cpr1Size,
+                    cpr2_size: abi.cpr2Size,
+                    fp_abi: abi.fpAbi,
+                    isa_extension: abi.isaExtension,
+                    ases: abi.ases,
+                    flags1: abi.flags1,
+                    flags2: abi.flags2,
+                },
+        },
+        mips_support_lane: "elf32-exec-o32-arch32r2-standard-v3",
+    };
+};

package/dist/ghidra/GhidraProvider.js

@@ -2,15 +2,26 @@ import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import {} from "../application/AnalysisProvider.js";
 import { createAnalysisProfile, } from "../domain/analysisProfile.js";
 import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
-import { ok } from "../domain/result.js";
+import { err, ok } from "../domain/result.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
 import { GhidraClient } from "./GhidraClient.js";
 import { ghidraInstallationDiagnostics, inspectGhidraInstallation, } from "./GhidraInstallation.js";
 import { resolveGhidraAnalysisProfile } from "./GhidraAnalysisProfile.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { resolveGhidraAnalysisSeeds } from "./GhidraAnalysisSeeds.js";
+import { admitGhidraLanguageOverride, readGhidraLanguageCatalog, } from "./GhidraLanguageCatalog.js";
+import { ghidraMipsUnsupportedReason } from "./GhidraMipsProfile.js";
 import { resolveGhidraExtensions } from "./extensions/GhidraExtensions.js";
 import { CAPABILITIES, windowsP0Capabilities, GHIDRA_PROVIDER_IDENTITY, GHIDRA_OPERATIONS, } from "./GhidraProviderCapabilities.js";
 import { createGhidraProviderClient, } from "./GhidraProviderClient.js";
 import { windowsNativeAuthorityUnavailableReason, hasWindowsNativeAuthority, windowsNativeCapabilities, } from "../process/WindowsAuthority.js";
-const SUPPORTED_ARCHITECTURES = new Set(["x86", "x86_64", "arm", "arm64"]);
+const SUPPORTED_ARCHITECTURES = new Set([
+    "x86",
+    "x86_64",
+    "arm",
+    "arm64",
+    "mips",
+]);
 /** Ghidra candidate backed by an isolated ephemeral headless import. */
 export class GhidraProvider {
     config;
@@ -85,6 +96,14 @@ export class GhidraProvider {
             };
         if (hostPlatform === "win32")
             return inspectWindowsP0TargetSupport(target, diagnostics);
+        const mipsReason = ghidraMipsUnsupportedReason(target);
+        if (mipsReason !== null)
+            return {
+                status: "unsupported",
+                code: "architecture_unsupported",
+                reason: mipsReason,
+                diagnostics,
+            };
         if (target.format === "mach-o" && target.availableArchitectures.length > 1)
             return {
                 status: "unsupported",
@@ -96,7 +115,7 @@ export class GhidraProvider {
             return {
                 status: "unsupported",
                 code: "architecture_unsupported",
-                reason: "Ghidra v1 requires a concrete x86, x86_64, arm, or arm64 target architecture.",
+                reason: "Ghidra v1 requires a supported x86, x86_64, arm, arm64, or MIPS target profile.",
                 diagnostics,
             };
         return {
@@ -108,19 +127,47 @@ export class GhidraProvider {
     }
     async resolveAnalysisProfile(target, options) {
         const installation = this.#inspectInstallation();
-        const resolved = await resolveGhidraAnalysisProfile(target, GHIDRA_PROVIDER_IDENTITY, installation, options?.signal);
+        const resolved = await resolveGhidraAnalysisProfile(target, GHIDRA_PROVIDER_IDENTITY, installation, options?.signal, this.config.ghidraLanguageOverride);
         if (!resolved.ok || resolved.value.profile === null)
             return resolved;
+        const override = this.config.ghidraLanguageOverride;
+        if (override !== undefined && installation.status === "available") {
+            let catalog;
+            try {
+                catalog = await readGhidraLanguageCatalog(installation.installDir);
+            }
+            catch (cause) {
+                return err(new ProviderAdapterError("ghidra", "resolve_analysis_profile", {
+                    cause,
+                    diagnostics: {
+                        reason: "Could not read the installed Ghidra language definitions.",
+                    },
+                }));
+            }
+            const refused = admitGhidraLanguageOverride(override, catalog, installation.providerVersion);
+            if (refused !== null)
+                return err(refused);
+        }
         const extensions = await resolveGhidraExtensions(this.config, target, installation.platform, options?.signal);
         if (!extensions.ok)
             return extensions;
-        if (extensions.value.length === 0)
+        if (options?.signal?.aborted === true)
+            return err(new AnalysisCancelledError("open_binary"));
+        const seeds = await resolveGhidraAnalysisSeeds(this.config.ghidraSeedFile);
+        if (!seeds.ok)
+            return seeds;
+        if (extensions.value.length === 0 && seeds.value === undefined)
             return resolved;
         return ok({
             ...resolved.value,
             profile: createAnalysisProfile(resolved.value.profile.provider, {
                 ...resolved.value.profile.parameters,
-                analysis_extensions: jsonValueSchema.parse(extensions.value),
+                ...(extensions.value.length === 0
+                    ? {}
+                    : { analysis_extensions: jsonValueSchema.parse(extensions.value) }),
+                ...(seeds.value === undefined
+                    ? {}
+                    : { analysis_seeds: jsonValueSchema.parse(seeds.value) }),
             }),
         });
     }
@@ -174,18 +221,19 @@ const inspectWindowsP0TargetSupport = (target, diagnostics) => {
             reason: "Windows Ghidra P0 accepts x86 and x86-64 PE targets only.",
             diagnostics,
         };
-    if (target.executableRole !== "application")
+    if (target.executableRole !== "application" &&
+        target.executableRole !== "shared-library")
         return {
             status: "unsupported",
             code: "target_role_unsupported",
-            reason: "Windows Ghidra P0 accepts PE applications, not DLL or non-executable images.",
+            reason: "Windows Ghidra P0 accepts PE applications and DLLs, not non-executable or unclassified images.",
             diagnostics,
         };
     if (target.managed !== false)
         return {
             status: "unsupported",
             code: "managed_target_unsupported",
-            reason: "Windows Ghidra P0 accepts native PE applications; managed or unclassified PE targets are unsupported.",
+            reason: "Windows Ghidra P0 accepts native PE applications and DLLs; managed or unclassified PE targets are unsupported.",
             diagnostics,
         };
     return {

package/dist/ghidra/GhidraProviderCapabilities.js

@@ -1,6 +1,7 @@
 import { hasWindowsNativeAuthority, windowsNativeAuthorityUnavailableReason, } from "../process/WindowsAuthority.js";
 import { GHIDRA_FUNCTION_OPERATIONS } from "./GhidraFunctionValues.js";
 import { GHIDRA_INVENTORY_OPERATIONS } from "./GhidraInventoryValues.js";
+import { GHIDRA_MUTATING_OPERATIONS } from "./GhidraSessionValues.js";
 /** Public identity committed by every Ghidra-backed observation. */
 export const GHIDRA_PROVIDER_IDENTITY = Object.freeze({
     id: "ghidra",
@@ -20,10 +21,12 @@ export const healthLimitations = Object.freeze([
 ]);
 /** Additional limitations applied to the experimental Windows x64 P0 boundary. */
 export const windowsP0Limitations = Object.freeze([
-    "Windows Ghidra P0 accepts approved native x86 and x86-64 PE applications only; DLL, managed, hostile, sensitive, and mutable-path targets are unsupported.",
+    "Windows Ghidra P0 accepts approved native x86 and x86-64 PE applications and DLLs; managed, hostile, sensitive, and mutable-path targets are unsupported.",
     "The Windows bridge uses authenticated IPv4 loopback because Node path-based IPC does not expose Java AF_UNIX sockets; the endpoint file contains no bearer token.",
     "Windows sessions require the matching packaged Windows x64 native addon, local NTFS targets and runtimes, and Windows 10 or later. Native handles enforce path admission, private DACLs, and Job Object ownership automatically.",
 ]);
+const stringInventoryLimitation = "Only Ghidra-defined string Data is observed; packed or undefined string bytes may be absent. Completeness applies to that inventory, and an empty search does not establish that text is absent from the artifact. If an address is known, use read_bytes and xrefs to inspect bytes and references.";
+const searchLimitation = "Regex mode uses Java Pattern semantics. Matcher or compiler stack exhaustion returns a resource constraint without closing the session; literal mode avoids regex recursion and returns complete matching values.";
 /** Limitation text for one admitted operation, including the common base. */
 export const limitationsFor = (operation) => {
     const common = [
@@ -38,6 +41,14 @@ export const limitationsFor = (operation) => {
                 "Annotation text rejects NUL and unpaired Unicode surrogates before mutation, with the field and UTF-16 index in the error. Supported Unicode and line endings are preserved.",
                 "Metadata edits invalidate immutable analysis snapshots and are discarded on close. CLI returns the updated dossier before session cleanup; this is not a saved Ghidra project.",
             ];
+        case "set_address_name":
+        case "set_addresses_names":
+            return [
+                ...common,
+                "Names use Ghidra USER_DEFINED source. A local function entry renames that function; any other mapped address receives a new or renamed primary label. Existing symbols retain their namespace and accept leaf names or qualified names within that namespace; qualified readback can be reused without adding namespace prefixes. Readback compares the primary symbol name.",
+                "set_addresses_names applies each address in its own transaction and reports per-address success; invalid names, unmapped addresses, and readback mismatches roll back only that address.",
+                "Metadata edits invalidate immutable analysis snapshots and are discarded on close; this is not a saved Ghidra project.",
+            ];
         case "inspect_native_load_image":
             return [
                 ...common,
@@ -72,7 +83,8 @@ export const limitationsFor = (operation) => {
         case "list_strings":
             return [
                 ...common,
-                "Only Ghidra-defined string Data is observed; charset is reported, while a non-missing terminator cannot distinguish a present terminator from a fixed or Pascal layout.",
+                stringInventoryLimitation,
+                "Charset is reported, while a non-missing terminator cannot distinguish a present terminator from a fixed or Pascal layout.",
             ];
         case "resolve_containing_procedure":
             return [
@@ -85,11 +97,9 @@ export const limitationsFor = (operation) => {
                 "Memory-block end addresses are exclusive; permissions come from Ghidra MemoryBlock flags rather than inference from section names.",
             ];
         case "search_procedures":
+            return [...common, searchLimitation];
         case "search_strings":
-            return [
-                ...common,
-                "Regex mode uses Java Pattern semantics. Matcher or compiler stack exhaustion returns a resource constraint without closing the session; literal mode avoids regex recursion and returns complete matching values.",
-            ];
+            return [...common, stringInventoryLimitation, searchLimitation];
         case "procedure_pseudo_code":
             return [
                 ...common,
@@ -148,12 +158,12 @@ export const CAPABILITIES = Object.freeze(GHIDRA_OPERATIONS.map((operation) => {
         reason: null,
         // Project writes are private import machinery. Analysis reads are bound
         // to the artifact/profile; session annotations disable snapshot replay.
-        ...(operation === "annotate_native_function" ||
+        ...(GHIDRA_MUTATING_OPERATIONS.has(operation) ||
             operation === "list_documents"
             ? {}
             : { cachePolicy: "snapshot" }),
         effects: Object.freeze({
-            mutatesArtifact: operation === "annotate_native_function",
+            mutatesArtifact: GHIDRA_MUTATING_OPERATIONS.has(operation),
             launchesProcess: true,
             mayShowUi: false,
             mayAccessNetwork: false,