rea-agents 6.4.0 → 6.7.0

package/dist/ghidra/GhidraPowerPcProfile.js

@@ -0,0 +1,51 @@
+/**
+ * Generic 32-bit big-endian PowerPC. Ghidra's ELF loader selects the e500
+ * (Book-E/SPE) variant for a plain EM_PPC header, so the lane binds this
+ * language instead of accepting the loader's choice.
+ */
+export const GHIDRA_POWERPC_LANGUAGE = {
+    languageId: "PowerPC:BE:32:default",
+    compilerSpecId: "default",
+};
+/** Keep family recognition separate from the deliberately bounded Ghidra lane. */
+export const ghidraPowerPcUnsupportedReason = (target) => {
+    if (target.kind !== "executable" || target.architecture !== "powerpc")
+        return null;
+    const metadata = target.powerpc;
+    if (target.format !== "elf" || metadata === undefined)
+        return "PowerPC analysis requires ELF header metadata; a family name alone does not select a processor variant.";
+    if (metadata.elfClass !== 32)
+        return "This Ghidra PowerPC lane supports ELF32 only; PPC64 remains unsupported.";
+    if (metadata.byteOrder !== "big")
+        return "This Ghidra PowerPC lane supports big-endian ELF32 only; little-endian PowerPC needs separate verification.";
+    if (metadata.type !== 2)
+        return "This Ghidra PowerPC lane supports ET_EXEC only; relocatable objects and shared images need separate load verification.";
+    // EF_PPC_EMB (0x80000000) marks embedded variants; other bits only declare
+    // relocation conventions that do not change instruction decoding.
+    if ((metadata.flags & 0x80000000) !== 0)
+        return "EF_PPC_EMB declares an embedded PowerPC variant that needs a separately supported processor profile.";
+    return null;
+};
+/**
+ * The language the lane imports with, unless REA_GHIDRA_LANGUAGE_ID already
+ * selected one through the committed profile.
+ */
+export const ghidraPowerPcLanguage = (target) => target.kind === "executable" && target.architecture === "powerpc"
+    ? GHIDRA_POWERPC_LANGUAGE
+    : undefined;
+/** Commit source ELF interpretation without confusing target ISA with host CPU. */
+export const ghidraPowerPcProfileParameters = (target) => {
+    if (target.kind !== "executable" ||
+        target.architecture !== "powerpc" ||
+        target.powerpc === undefined)
+        return {};
+    return {
+        powerpc_elf: {
+            elf_class: target.powerpc.elfClass,
+            byte_order: target.powerpc.byteOrder,
+            type: target.powerpc.type,
+            flags: target.powerpc.flags,
+        },
+        powerpc_support_lane: "elf32-be-exec-generic-v1",
+    };
+};

package/dist/ghidra/GhidraProvider.js

@@ -1,26 +1,40 @@
+import { DeferredAnalysisClient } from "../providers/DeferredAnalysisClient.js";
+import { analysisClientFailureForOperation } from "../providers/AnalysisClientFailure.js";
+import { AnalysisCleanupLease } from "../artifacts/AnalysisCleanupLease.js";
+import { SharedStartupAttempt, STARTUP_OWNER_CLOSED, } from "../process/SharedStartupAttempt.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { bindArtifactFileCleanup } from "../artifacts/ArtifactFileOperation.js";
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
-import {} from "../application/AnalysisProvider.js";
 import { createAnalysisProfile, } from "../domain/analysisProfile.js";
+import { isMachOFormat, } from "../domain/binaryTargetTypes.js";
 import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.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 { admitGhidraLanguageOverride, GhidraLanguageCatalogCleanupError, readGhidraLanguageCatalog, } from "./GhidraLanguageCatalog.js";
+import { ghidraProcessorUnsupportedReason, isGhidraPspTarget, } from "./GhidraPspProfile.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";
+import { CAPABILITIES, windowsP0Capabilities, GHIDRA_PROVIDER_IDENTITY, WINDOWS_P0_NATIVE_PE_ARCHITECTURES, } from "./GhidraProviderCapabilities.js";
+import { createGhidraProviderClient, admitGhidraClient, } from "./GhidraProviderClient.js";
+import { inspectWindowsNativeReadiness, windowsNativeCapabilities, } from "../process/WindowsAuthority.js";
 const SUPPORTED_ARCHITECTURES = new Set([
     "x86",
     "x86_64",
     "arm",
     "arm64",
     "mips",
+    "6502",
+    "riscv",
+    "powerpc",
+    "m68k",
+    "hexagon",
 ]);
 /** Ghidra candidate backed by an isolated ephemeral headless import. */
 export class GhidraProvider {
@@ -28,7 +42,20 @@ export class GhidraProvider {
     logger;
     installationHost;
     clientFactory;
-    #installation;
+    #inspectionResources = new ArtifactResourceScope();
+    #inspectionWork = new Set();
+    #lifetime = new AbortController();
+    #observations = new WeakMap();
+    #inspectionAttempt;
+    #inspectionOwner = {
+        retain: (owner, resource) => this.#inspectionResources.retain({
+            kind: "lease",
+            resource,
+            lease: AnalysisCleanupLease.forCloseOwner(owner, resource),
+        }),
+        run: (operation) => this.#inspectionResources.run(operation),
+    };
+    #closing;
     environment;
     constructor(config, logger, environment, installationHost, clientFactory = (options) => new GhidraClient(options)) {
         this.config = config;
@@ -45,19 +72,44 @@ export class GhidraProvider {
             ? windowsP0Capabilities()
             : CAPABILITIES;
     }
-    inspectAvailability() {
-        const installation = this.#inspectInstallation();
+    async inspectAvailability(options = {}) {
+        return (await this.inspectReadinessSnapshot(options)).availability;
+    }
+    inspectReadinessSnapshot(options = {}) {
+        return this.#runInspectionWork((signal) => this.#readinessSnapshot(signal, options.scope), options.signal);
+    }
+    async #readinessSnapshot(signal, scope) {
+        const installation = await this.#inspectInstallation(signal, "binary_session", scope);
+        const readiness = installation.platform === "win32"
+            ? inspectWindowsNativeReadiness(installation.platform)
+            : undefined;
+        const availability = this.#availability(installation, readiness);
+        if (availability.status === "available" && signal.aborted)
+            throw new AnalysisCancelledError("binary_session", {
+                cause: signal.reason,
+                diagnostics: availability.diagnostics,
+            });
+        return {
+            availability,
+            capabilities: readiness === undefined
+                ? CAPABILITIES
+                : windowsP0Capabilities(readiness),
+        };
+    }
+    #availability(installation, readiness) {
         const diagnostics = ghidraInstallationDiagnostics(installation);
-        if (installation.status === "available" &&
-            installation.platform === "win32" &&
-            !hasWindowsNativeAuthority(installation.platform))
+        if (installation.status === "available" && readiness?.available === false)
             return {
                 status: "unavailable",
-                code: "unsupported_host",
-                reason: windowsNativeAuthorityUnavailableReason(installation.platform),
+                code: readiness.code,
+                reason: readiness.reason,
                 diagnostics: {
                     ...diagnostics,
-                    windows_security: jsonObjectSchema.parse(windowsNativeCapabilities(installation.platform)),
+                    windows_security: jsonObjectSchema.parse(windowsNativeCapabilities(installation.platform, readiness)),
+                    windows_native_failure: {
+                        stage: readiness.failureStage,
+                        remediation: readiness.remediation,
+                    },
                 },
             };
         return installation.status === "available"
@@ -96,7 +148,11 @@ export class GhidraProvider {
             };
         if (hostPlatform === "win32")
             return inspectWindowsP0TargetSupport(target, diagnostics);
-        const mipsReason = ghidraMipsUnsupportedReason(target);
+        const mipsReason = isGhidraPspTarget(target) &&
+            (hostPlatform !== "linux" ||
+                (this.installationHost?.architecture ?? process.arch) !== "x64")
+            ? "The initial PSP Allegrex profile is verified on Linux x64 only."
+            : ghidraProcessorUnsupportedReason(target);
         if (mipsReason !== null)
             return {
                 status: "unsupported",
@@ -104,7 +160,8 @@ export class GhidraProvider {
                 reason: mipsReason,
                 diagnostics,
             };
-        if (target.format === "mach-o" && target.availableArchitectures.length > 1)
+        if (isMachOFormat(target.format) &&
+            target.availableArchitectures.length > 1)
             return {
                 status: "unsupported",
                 code: "architecture_unsupported",
@@ -115,7 +172,7 @@ export class GhidraProvider {
             return {
                 status: "unsupported",
                 code: "architecture_unsupported",
-                reason: "Ghidra v1 requires a supported x86, x86_64, arm, arm64, or MIPS target profile.",
+                reason: "Ghidra v1 requires a supported x86, x86_64, arm, arm64, MIPS, RISC-V, raw 6502, or raw m68k target profile.",
                 diagnostics,
             };
         return {
@@ -125,9 +182,71 @@ export class GhidraProvider {
             diagnostics,
         };
     }
+    hasPendingOwnedResources() {
+        return (this.#inspectionWork.size > 0 ||
+            this.#inspectionAttempt !== undefined ||
+            this.#inspectionResources.hasPending);
+    }
+    closeOwnedResources() {
+        this.#closing ??= Promise.resolve()
+            .then(async () => {
+            this.#lifetime.abort(STARTUP_OWNER_CLOSED);
+            this.#inspectionAttempt?.close();
+            await Promise.allSettled([
+                ...this.#inspectionWork,
+                ...(this.#inspectionAttempt === undefined
+                    ? []
+                    : [this.#inspectionAttempt.promise]),
+            ]);
+            return this.#closeInspectionResources();
+        })
+            .finally(() => {
+            this.#lifetime = new AbortController();
+            this.#closing = undefined;
+        });
+        return this.#closing;
+    }
+    async #closeInspectionResources() {
+        try {
+            await this.#inspectionResources.retryCleanup();
+            return ok(null);
+        }
+        catch (cause) {
+            const error = new ProviderCleanupError("ghidra", cause instanceof ArtifactReaderFailure
+                ? (cause.cleanup?.resources ?? [])
+                : [], { reason: providerFailureText(cause) }, { cause });
+            bindArtifactFileCleanup(cause, error);
+            return err(error);
+        }
+    }
     async resolveAnalysisProfile(target, options) {
-        const installation = this.#inspectInstallation();
-        const resolved = await resolveGhidraAnalysisProfile(target, GHIDRA_PROVIDER_IDENTITY, installation, options?.signal, this.config.ghidraLanguageOverride);
+        try {
+            return await this.#runInspectionWork(async (signal) => {
+                const result = await this.#resolveProfile(target, {
+                    ...options,
+                    signal,
+                });
+                if (!result.ok && result.error instanceof AnalysisCancelledError)
+                    return err(analysisClientFailureForOperation(result.error, "ghidra", "open_binary"));
+                if (result.ok && signal.aborted)
+                    return err(new AnalysisCancelledError("open_binary", {
+                        cause: signal.reason,
+                        diagnostics: {
+                            completed_profile_digest: result.value.profile?.digest ?? null,
+                        },
+                    }));
+                return result;
+            }, options?.signal);
+        }
+        catch (cause) {
+            return err(analysisClientFailureForOperation(cause, "ghidra", cause instanceof AnalysisCancelledError
+                ? "open_binary"
+                : "resolve_analysis_profile"));
+        }
+    }
+    async #resolveProfile(target, options) {
+        const installation = await this.#inspectInstallation(options?.signal, "resolve_analysis_profile", options?.scope);
+        const resolved = await resolveGhidraAnalysisProfile(target, GHIDRA_PROVIDER_IDENTITY, installation, this.#inspectionResources, options?.signal, this.config.ghidraLanguageOverride, this.config.ghidraDisabledAnalyzers);
         if (!resolved.ok || resolved.value.profile === null)
             return resolved;
         const override = this.config.ghidraLanguageOverride;
@@ -137,6 +256,15 @@ export class GhidraProvider {
                 catalog = await readGhidraLanguageCatalog(installation.installDir);
             }
             catch (cause) {
+                if (cause instanceof GhidraLanguageCatalogCleanupError)
+                    return err(new ProviderCleanupError("ghidra", cause.paths, {
+                        reason: cause.message,
+                        paths: [...cause.paths],
+                        close_failures: cause.causes.map(providerFailureText),
+                        ...(cause.readFailure === undefined
+                            ? {}
+                            : { read_failure: providerFailureText(cause.readFailure) }),
+                    }, { operation: "resolve_analysis_profile", cause }));
                 return err(new ProviderAdapterError("ghidra", "resolve_analysis_profile", {
                     cause,
                     diagnostics: {
@@ -148,12 +276,14 @@ export class GhidraProvider {
             if (refused !== null)
                 return err(refused);
         }
-        const extensions = await resolveGhidraExtensions(this.config, target, installation.platform, options?.signal);
+        const extensions = await resolveGhidraExtensions(this.config, target, installation.platform, this.#inspectionResources, options?.signal);
         if (!extensions.ok)
             return extensions;
         if (options?.signal?.aborted === true)
-            return err(new AnalysisCancelledError("open_binary"));
-        const seeds = await resolveGhidraAnalysisSeeds(this.config.ghidraSeedFile);
+            return err(new AnalysisCancelledError("open_binary", {
+                cause: options.signal.reason,
+            }));
+        const seeds = await resolveGhidraAnalysisSeeds(this.config.ghidraSeedFile, this.#inspectionResources, options?.signal);
         if (!seeds.ok)
             return seeds;
         if (extensions.value.length === 0 && seeds.value === undefined)
@@ -172,19 +302,104 @@ export class GhidraProvider {
         });
     }
     createClient(target, profile, context) {
-        return createGhidraProviderClient({
-            config: this.config,
-            environment: this.environment,
-            logger: this.logger,
-            clientFactory: this.clientFactory,
-            target,
-            ...(profile === undefined ? {} : { profile }),
-            ...(context === undefined ? {} : { context }),
-            installation: this.#inspectInstallation(),
-        });
+        return new DeferredAnalysisClient(async (signal, resourceOwner) => {
+            const admitted = admitGhidraClient(target, profile, this.installationHost?.platform ?? process.platform);
+            if (!admitted.ok)
+                throw admitted.error;
+            const installation = await this.#observeInstallation(signal, resourceOwner);
+            const created = createGhidraProviderClient({
+                config: this.config,
+                environment: this.environment,
+                logger: this.logger,
+                clientFactory: this.clientFactory,
+                admission: admitted.value,
+                ...(context === undefined ? {} : { context }),
+                installation,
+                signal,
+            });
+            if (!created.ok)
+                throw created.error;
+            return created.value;
+        }, "ghidra");
+    }
+    async #runInspectionWork(operation, callerSignal) {
+        if (this.#closing !== undefined) {
+            const closed = await this.#closing;
+            if (!closed.ok)
+                throw closed.error;
+        }
+        const signal = callerSignal === undefined
+            ? this.#lifetime.signal
+            : AbortSignal.any([callerSignal, this.#lifetime.signal]);
+        if (signal.aborted)
+            throw new AnalysisCancelledError("ghidra:inspection", {
+                cause: signal.reason,
+            });
+        const work = Promise.resolve().then(() => operation(signal));
+        this.#inspectionWork.add(work);
+        try {
+            return await work;
+        }
+        finally {
+            this.#inspectionWork.delete(work);
+        }
     }
-    #inspectInstallation() {
+    async #inspectInstallation(callerSignal, operation, scope) {
+        if (callerSignal?.aborted)
+            throw new AnalysisCancelledError(operation, {
+                cause: callerSignal.reason,
+            });
+        if (scope?.active) {
+            const observed = this.#observations.get(scope);
+            if (observed?.lifetime === this.#lifetime.signal)
+                return observed.installation;
+        }
+        let attempt = this.#inspectionAttempt;
+        if (attempt === undefined) {
+            attempt = new SharedStartupAttempt((signal) => Promise.resolve().then(async () => {
+                try {
+                    return ok(await this.#observeInstallation(signal));
+                }
+                catch (cause) {
+                    return err(analysisClientFailureForOperation(cause, "ghidra", "ghidra:inspection"));
+                }
+            }), this.#lifetime.signal);
+            const owned = attempt;
+            this.#inspectionAttempt = owned;
+            void owned.promise.then(() => {
+                if (this.#inspectionAttempt === owned)
+                    this.#inspectionAttempt = undefined;
+            }, () => {
+                if (this.#inspectionAttempt === owned)
+                    this.#inspectionAttempt = undefined;
+            });
+        }
+        const waited = await attempt.wait(callerSignal);
+        if (waited.status === "cancelled")
+            throw new AnalysisCancelledError(operation, {
+                cause: callerSignal?.reason,
+            });
+        if (!waited.value.ok)
+            throw analysisClientFailureForOperation(waited.value.error, "ghidra", operation);
+        if (waited.value.value.status === "available" &&
+            (callerSignal?.aborted || attempt.signal.aborted))
+            throw new AnalysisCancelledError(operation, {
+                cause: callerSignal?.aborted
+                    ? callerSignal.reason
+                    : attempt.signal.reason,
+                diagnostics: ghidraInstallationDiagnostics(waited.value.value),
+            });
+        if (scope?.active && !callerSignal?.aborted && !attempt.signal.aborted)
+            this.#observations.set(scope, {
+                lifetime: this.#lifetime.signal,
+                installation: waited.value.value,
+            });
+        return waited.value.value;
+    }
+    #observeInstallation(signal, resourceOwner = this.#inspectionOwner) {
         const options = {
+            resourceOwner,
+            signal,
             environment: this.environment,
             ...(this.config.ghidraInstallDir === undefined
                 ? {}
@@ -199,26 +414,28 @@ export class GhidraProvider {
                 ? {}
                 : { architecture: this.installationHost.architecture }),
         };
-        this.#installation ??=
-            this.installationHost === undefined
-                ? inspectGhidraInstallation(options)
-                : inspectGhidraInstallation(options, this.installationHost);
-        return this.#installation;
+        return this.installationHost === undefined
+            ? inspectGhidraInstallation(options)
+            : inspectGhidraInstallation(options, this.installationHost);
     }
 }
+const providerFailureText = (cause) => cause instanceof Error ? cause.message : String(cause);
 const inspectWindowsP0TargetSupport = (target, diagnostics) => {
+    // The raw 6502 lane uses the same immutable snapshot and native ownership boundary.
+    if (target.format === "raw-binary" && target.architecture === "6502")
+        return { status: "supported", code: null, reason: null, diagnostics };
     if (target.format !== "pe")
         return {
             status: "unsupported",
             code: "target_format_unsupported",
-            reason: "Windows Ghidra P0 accepts PE targets only.",
+            reason: "Windows Ghidra P0 accepts native PE and explicitly selected raw 6502 targets only.",
             diagnostics,
         };
-    if (target.architecture !== "x86" && target.architecture !== "x86_64")
+    if (!WINDOWS_P0_NATIVE_PE_ARCHITECTURES.includes(target.architecture))
         return {
             status: "unsupported",
             code: "architecture_unsupported",
-            reason: "Windows Ghidra P0 accepts x86 and x86-64 PE targets only.",
+            reason: "Windows Ghidra P0 accepts x86, x86-64, ARM and ARM64 PE targets only.",
             diagnostics,
         };
     if (target.executableRole !== "application" &&
@@ -236,6 +453,14 @@ const inspectWindowsP0TargetSupport = (target, diagnostics) => {
             reason: "Windows Ghidra P0 accepts native PE applications and DLLs; managed or unclassified PE targets are unsupported.",
             diagnostics,
         };
+    if ((target.architecture === "arm" && target.peMachine !== 0x01c4) ||
+        (target.architecture === "arm64" && target.peMachine !== 0xaa64))
+        return {
+            status: "unsupported",
+            code: "architecture_unsupported",
+            reason: "Windows Ghidra P0 ARM PE targets require observed ARMNT (0x01c4) or ARM64 (0xaa64) COFF machines; legacy ARM/Thumb and unknown machines are unsupported.",
+            diagnostics: { ...diagnostics, pe_machine: target.peMachine ?? null },
+        };
     return {
         status: "supported",
         code: null,

package/dist/ghidra/GhidraProviderCapabilities.js

@@ -1,18 +1,24 @@
-import { hasWindowsNativeAuthority, windowsNativeAuthorityUnavailableReason, } from "../process/WindowsAuthority.js";
+import { inspectWindowsNativeReadiness, } 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";
+/** Target architectures admitted by the Windows P0 native PE boundary. */
+export const WINDOWS_P0_NATIVE_PE_ARCHITECTURES = Object.freeze(["x86", "x86_64", "arm", "arm64"]);
 /** Public identity committed by every Ghidra-backed observation. */
 export const GHIDRA_PROVIDER_IDENTITY = Object.freeze({
     id: "ghidra",
     name: "Ghidra",
     version: null,
 });
-/** Analyst operations implemented by the Ghidra inventory and function adapters. */
-export const GHIDRA_OPERATIONS = Object.freeze([
+/** Provider observations, including internal aggregates consumed by workflows. */
+const providerOperations = Object.freeze([
     ...GHIDRA_INVENTORY_OPERATIONS,
     ...GHIDRA_FUNCTION_OPERATIONS,
 ]);
+/** Public analyst tools backed by these observations; aggregates stay internal. */
+export const GHIDRA_OPERATIONS = Object.freeze(providerOperations.map((operation) => operation === "read_binary_inventory_summary"
+    ? "binary_overview"
+    : operation));
 /** Health limitations shared by every Ghidra-backed capability. */
 export const healthLimitations = Object.freeze([
     "The session serves operations only after Ghidra reports default auto-analysis complete; incomplete analysis does not expose partial results.",
@@ -21,7 +27,7 @@ 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 and DLLs; managed, hostile, sensitive, and mutable-path targets are unsupported.",
+    "Windows Ghidra P0 accepts native x86, x86-64, ARMNT (Thumb-2) and ARM64 PE applications and DLLs, and explicitly selected raw 6502 images; 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.",
 ]);
@@ -34,6 +40,13 @@ export const limitationsFor = (operation) => {
         "Default-space addresses use lowercase 0x-prefixed hexadecimal; other address spaces use <percent-encoded-space>:0x<hex>.",
     ];
     switch (operation) {
+        case "read_binary_inventory_summary":
+            return [
+                ...common,
+                stringInventoryLimitation,
+                "Counts use the complete defined-string inventory and the same local/external function inventory as list_strings and list_procedures. They do not establish discovery of undefined strings or unidentified functions.",
+                "Memory-block end addresses are exclusive; segment lengths use those observed address coordinates.",
+            ];
         case "annotate_native_function":
             return [
                 ...common,
@@ -52,13 +65,18 @@ export const limitationsFor = (operation) => {
         case "inspect_native_load_image":
             return [
                 ...common,
-                "Independent verification supports DOS MZ and explicitly selected COM, including measured COM entry context. Measured source mappings use inclusive end addresses and complete region digests; no target execution or project mutation occurs.",
+                "Independent verification covers admitted DOS MZ, explicitly selected COM with measured entry context, and caller-supplied raw-binary imports. Measured source mappings use inclusive end addresses and complete region digests; no target execution or project mutation occurs.",
             ];
         case "read_bytes":
             return [
                 ...common,
                 "Bytes reflect Ghidra's initialized memory, including loader fixups. Reads stop at an unmapped or uninitialized byte and report completeness explicitly.",
             ];
+        case "search_bytes":
+            return [
+                ...common,
+                "Searches initialized loader-adjusted memory independently per block, in provider address order. Bounds and page coverage ends are inclusive. Uninitialized blocks are listed separately. Overlapping matches are included; patterns never cross block boundaries. A cursor resumes the same target, profile and query. Cancellation discards the active search and returns no successful partial page.",
+            ];
         case "address_to_file_offset":
             return [
                 ...common,
@@ -119,10 +137,7 @@ export const limitationsFor = (operation) => {
             ];
         case "procedure_callers":
         case "procedure_callees":
-            return [
-                ...common,
-                "Only resolved Ghidra call references are returned; unresolved computed or indirect calls remain unknown, while function classifications distinguish thunks and externals.",
-            ];
+            return common;
         case "xrefs":
             return [
                 ...common,
@@ -150,7 +165,7 @@ export const limitationsFor = (operation) => {
     }
 };
 /** Provider-neutral capabilities advertised by every non-Windows Ghidra session. */
-export const CAPABILITIES = Object.freeze(GHIDRA_OPERATIONS.map((operation) => {
+export const CAPABILITIES = Object.freeze(providerOperations.map((operation) => {
     return Object.freeze({
         provider: GHIDRA_PROVIDER_IDENTITY,
         operation,
@@ -175,8 +190,7 @@ export const CAPABILITIES = Object.freeze(GHIDRA_OPERATIONS.map((operation) => {
     });
 }));
 /** Capabilities advertised for the experimental Windows x64 P0 boundary. */
-export const windowsP0Capabilities = () => {
-    const available = hasWindowsNativeAuthority("win32");
+export const windowsP0Capabilities = (readiness = inspectWindowsNativeReadiness("win32")) => {
     return Object.freeze(CAPABILITIES.map((capability) => {
         const limitations = Object.freeze([
             ...capability.limitations,
@@ -190,13 +204,13 @@ export const windowsP0Capabilities = () => {
                 availabilityCode: "unsupported_host",
                 limitations,
             });
-        return available
+        return readiness.available
             ? Object.freeze({ ...capability, limitations })
             : Object.freeze({
                 ...capability,
                 available: false,
-                reason: windowsNativeAuthorityUnavailableReason("win32"),
-                availabilityCode: "unsupported_host",
+                reason: readiness.reason,
+                availabilityCode: readiness.code,
                 limitations,
             });
     }));