rea-agents 2.5.0 → 3.1.0

package/dist/generatedPackageMetadata.js

@@ -1,9 +1,9 @@
 /** Generated from package.json and package-lock.json; do not edit. */
 export const PACKAGE_METADATA = {
     name: "rea-agents",
-    version: "2.5.0", // x-release-please-version
-    serverSdkVersion: "2.0.0-beta.4",
-    clientSdkVersion: "2.0.0-beta.4",
-    coreSdkVersion: "2.0.0-beta.4",
+    version: "3.1.0", // x-release-please-version
+    serverSdkVersion: "2.0.0",
+    clientSdkVersion: "2.0.0",
+    coreSdkVersion: "2.0.0",
     skillVersion: "23",
 };

package/dist/ghidra/GhidraClient.js

@@ -369,7 +369,7 @@ export class GhidraClient {
         return err(failure);
     }
     #interruptionFailure(deadline) {
-        return deadline.cancelled
+        return deadline.interruption === "cancelled"
             ? this.#failure("cancelled", "Ghidra startup was cancelled")
             : this.#failure("timeout", "Ghidra startup deadline elapsed", undefined, {
                 timeoutMs: deadline.timeoutMs,

package/dist/ghidra/GhidraClientStartup.js

@@ -22,7 +22,7 @@ export async function completeGhidraStartupHandshake(options) {
     }
     return parsed;
 }
-const interruptionFailure = (options) => options.deadline.cancelled
+const interruptionFailure = (options) => options.deadline.interruption === "cancelled"
     ? options.failure("cancelled", "Ghidra startup was cancelled")
     : options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
         timeoutMs: options.startupTimeoutMs,

package/dist/ghidra/GhidraDefaults.js

@@ -17,4 +17,4 @@ export const GHIDRA_MAX_QUEUED_REQUESTS = 32;
 /** Maximum encoded response line accepted from the Java bridge. */
 export const GHIDRA_MAX_LINE_BYTES = 1024 * 1024;
 /** Version of REA's Java bridge handshake and request protocol. */
-export const GHIDRA_BRIDGE_VERSION = 5;
+export const GHIDRA_BRIDGE_VERSION = 6;

package/dist/ghidra/GhidraFunctionValues.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisOutputError } from "../domain/errors.js";
 import { functionInstructionWindowSchema, functionDossierSchema, } from "../domain/hopperValues.js";
-import { jsonObjectSchema, jsonValueSchema, } from "../domain/jsonValue.js";
+import { nativeApiBoundarySchema } from "../domain/nativeApiBoundary.js";
 import { err, ok } from "../domain/result.js";
 import { ghidraBoundedIdentifierSchema, ghidraCanonicalAddressSchema, } from "./GhidraInventoryValues.js";
 /** Read-only function operations admitted by the Ghidra adapter. */
@@ -89,7 +89,7 @@ const inputSchemas = {
 export const parseGhidraFunctionInput = (operation, value) => {
     const parsed = inputSchemas[operation].safeParse(value);
     return parsed.success
-        ? ok(jsonObjectSchema.parse(parsed.data))
+        ? ok(parsed.data)
         : err(new AnalysisInputError(operation, { cause: parsed.error }));
 };
 const classification = z
@@ -142,15 +142,24 @@ const referenceEdge = z
     kind: referenceKind,
 })
     .strict();
-const boundedReferences = z
-    .object({
+const boundedReferenceFacts = {
     items: z.array(referenceEdge),
     total: z.number().int().min(0).nullable(),
     returned: z.number().int().min(0),
-    truncated: z.boolean(),
-    next_offset: z.number().int().min(0).nullable(),
-})
-    .strict()
+};
+const boundedReferences = z
+    .discriminatedUnion("truncated", [
+    z.strictObject({
+        ...boundedReferenceFacts,
+        truncated: z.literal(false),
+        next_offset: z.null(),
+    }),
+    z.strictObject({
+        ...boundedReferenceFacts,
+        truncated: z.literal(true),
+        next_offset: z.number().int().min(0).nullable(),
+    }),
+])
     .superRefine((value, context) => {
     if (value.returned !== value.items.length)
         context.addIssue({
@@ -164,12 +173,6 @@ const boundedReferences = z
             path: ["total"],
             message: "total cannot be smaller than returned",
         });
-    if (value.next_offset !== null && !value.truncated)
-        context.addIssue({
-            code: "custom",
-            path: ["next_offset"],
-            message: "a continuation requires truncated output",
-        });
 });
 const procedureReferences = z
     .object({
@@ -191,7 +194,32 @@ const procedureInfo = z
     classification,
 })
     .strict();
-const ghidraFunctionDossier = functionDossierSchema.superRefine((value, context) => {
+const ghidraNativeApiBoundary = nativeApiBoundarySchema.superRefine((value, context) => {
+    if (!value.available)
+        return;
+    if (value.provenance !== "ghidra-high-function")
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra native API observations require HighFunction provenance",
+        });
+    const addresses = value.jump_tables.flatMap((table) => [
+        table.dispatch_address,
+        ...table.data_sources.map(({ address }) => address),
+        ...table.mappings.flatMap(({ target_address, data_addresses }) => [
+            target_address,
+            ...data_addresses,
+        ]),
+    ]);
+    if (addresses.some((address) => !ghidraCanonicalAddressSchema.safeParse(address).success))
+        context.addIssue({
+            code: "custom",
+            message: "Ghidra native API observation contains a non-canonical address",
+        });
+});
+const ghidraFunctionDossier = functionDossierSchema
+    .extend({ native_api: ghidraNativeApiBoundary })
+    .strict()
+    .superRefine((value, context) => {
     const addresses = [
         value.procedure.address,
         ...value.comments.items.map(({ address }) => address),
@@ -261,7 +289,7 @@ const resultSchemas = {
 export const parseGhidraFunctionResult = (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 function-analysis contract", { cause: parsed.error }));
 };
 const referenceAddresses = (edge) => [

package/dist/ghidra/GhidraInventoryValues.js

@@ -1,6 +1,5 @@
 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. */
 export const GHIDRA_INVENTORY_OPERATIONS = [
@@ -60,7 +59,7 @@ 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()
@@ -104,50 +103,61 @@ 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 pageSchema = (item, maximumLimit) => {
+    const pageFacts = {
+        items: z.array(item),
+        offset: z.number().int().min(0),
+        limit: z.number().int().min(1).max(maximumLimit),
+        total: z.number().int().min(0),
+    };
+    return z
+        .discriminatedUnion("has_more", [
+        z.strictObject({
+            ...pageFacts,
+            has_more: z.literal(true),
+            next_offset: z.number().int().min(0),
+        }),
+        z.strictObject({
+            ...pageFacts,
+            has_more: z.literal(false),
+            next_offset: z.null(),
+        }),
+    ])
+        .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),
@@ -212,6 +222,6 @@ const resultSchemas = {
 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/GhidraProvider.js

@@ -1,5 +1,6 @@
 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";
@@ -10,9 +11,9 @@ import { ghidraInstallationDiagnostics, inspectGhidraInstallation, } from "./Ghi
 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,6 +38,18 @@ export class GhidraProvider {
     inspectAvailability() {
         const installation = this.#inspectInstallation();
         const diagnostics = ghidraInstallationDiagnostics(installation);
+        if (installation.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.available
             ? {
                 status: "available",
@@ -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",
@@ -237,6 +242,9 @@ const ghidraClientPrerequisites = (target, profile, installation) => {
         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({

package/dist/ghidra/GhidraProviderCapabilities.js

@@ -1,4 +1,5 @@
-import { ENHANCED_TOOL_CONTRACTS, OFFICIAL_TOOL_CONTRACTS, } from "../contracts/toolContracts.js";
+import { WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON } from "../process/WindowsAuthority.js";
+import { GENERATED_MCP_TOOL_CATALOG } from "../generatedMcpToolCatalog.js";
 import { GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS, GHIDRA_MAX_LINE_BYTES, GHIDRA_REQUEST_TIMEOUT_MS, } from "./GhidraDefaults.js";
 import { GHIDRA_FUNCTION_OPERATIONS } from "./GhidraFunctionValues.js";
 import { GHIDRA_INVENTORY_OPERATIONS } from "./GhidraInventoryValues.js";
@@ -8,10 +9,7 @@ export const GHIDRA_PROVIDER_IDENTITY = Object.freeze({
     name: "Ghidra",
     version: null,
 });
-const providerContractByName = new Map([...OFFICIAL_TOOL_CONTRACTS, ...ENHANCED_TOOL_CONTRACTS].map((contract) => [
-    contract.name,
-    contract,
-]));
+const providerContractByName = new Map(GENERATED_MCP_TOOL_CATALOG.filter(({ kind }) => kind === "official-proxy" || kind === "enhanced").map((contract) => [contract.name, contract]));
 /** Provider-neutral read-only contracts implemented by the Ghidra adapter. */
 export const GHIDRA_PROVIDER_TOOL_CONTRACTS = Object.freeze([...GHIDRA_INVENTORY_OPERATIONS, ...GHIDRA_FUNCTION_OPERATIONS].map((operation) => {
     const contract = providerContractByName.get(operation);
@@ -46,7 +44,7 @@ export const healthLimitations = Object.freeze([
 export const windowsP0Limitations = Object.freeze([
     "Windows Ghidra P0 accepts approved native x86-64 PE applications only; DLL, 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 P0 process-tree cleanup uses bounded taskkill termination and does not claim Job Object ownership, private DACL enforcement, or reparse-point-safe path authority.",
+    "Windows P0 is not admitted until a native authority proves Job Object ownership, private DACL enforcement, and reparse-safe path admission; bounded taskkill cleanup and chmod(0700) do not prove those controls.",
 ]);
 /** Limitation text for one admitted operation, including the common base. */
 export const limitationsFor = (operation) => {
@@ -137,42 +135,50 @@ export const limitationsFor = (operation) => {
     }
 };
 /** Provider-neutral capabilities advertised by every non-Windows Ghidra session. */
-export const CAPABILITIES = Object.freeze(GHIDRA_PROVIDER_TOOL_CONTRACTS.map((contract) => Object.freeze({
-    provider: GHIDRA_PROVIDER_IDENTITY,
-    operation: contract.name,
-    inputContractVersion: 1,
-    outputContractVersion: 1,
-    available: true,
-    reason: null,
-    pagination: PAGINATED_OPERATIONS.has(contract.name)
-        ? "offset"
-        : "none",
-    exhaustive: !PAGINATED_OPERATIONS.has(contract.name),
-    effects: Object.freeze({
-        mutatesArtifact: false,
-        launchesProcess: true,
-        mayShowUi: false,
-        mayAccessNetwork: false,
-        mayWriteFilesystem: true,
-        changesPermissions: false,
-        requiresRoot: false,
-    }),
-    limits: Object.freeze({
-        maxResults: PAGINATED_OPERATIONS.has(contract.name)
-            ? SEARCH_OPERATIONS.has(contract.name)
-                ? 100
-                : 500
-            : null,
-        maxPayloadBytes: GHIDRA_MAX_LINE_BYTES,
-        timeoutMs: DECOMPILE_OPERATIONS.has(contract.name)
-            ? GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS
-            : GHIDRA_REQUEST_TIMEOUT_MS,
-    }),
-    limitations: Object.freeze(limitationsFor(contract.name)),
-})));
+export const CAPABILITIES = Object.freeze(GHIDRA_PROVIDER_TOOL_CONTRACTS.map((contract) => {
+    const operation = contract.analysisOperation;
+    if (operation === null)
+        throw new TypeError(`Missing analysis operation for ${contract.name}`);
+    return Object.freeze({
+        provider: GHIDRA_PROVIDER_IDENTITY,
+        operation,
+        inputContractVersion: 1,
+        outputContractVersion: 1,
+        available: true,
+        reason: null,
+        pagination: PAGINATED_OPERATIONS.has(contract.name)
+            ? "offset"
+            : "none",
+        exhaustive: !PAGINATED_OPERATIONS.has(contract.name),
+        effects: Object.freeze({
+            mutatesArtifact: false,
+            launchesProcess: true,
+            mayShowUi: false,
+            mayAccessNetwork: false,
+            mayWriteFilesystem: true,
+            changesPermissions: false,
+            requiresRoot: false,
+        }),
+        limits: Object.freeze({
+            maxResults: PAGINATED_OPERATIONS.has(contract.name)
+                ? SEARCH_OPERATIONS.has(contract.name)
+                    ? 100
+                    : 500
+                : null,
+            maxPayloadBytes: GHIDRA_MAX_LINE_BYTES,
+            timeoutMs: DECOMPILE_OPERATIONS.has(contract.name)
+                ? GHIDRA_DECOMPILE_REQUEST_TIMEOUT_MS
+                : GHIDRA_REQUEST_TIMEOUT_MS,
+        }),
+        limitations: Object.freeze(limitationsFor(contract.name)),
+    });
+}));
 /** Capabilities advertised for the experimental Windows x64 P0 boundary. */
 export const WINDOWS_P0_CAPABILITIES = Object.freeze(CAPABILITIES.map((capability) => Object.freeze({
     ...capability,
+    available: false,
+    reason: WINDOWS_NATIVE_AUTHORITY_UNAVAILABLE_REASON,
+    availabilityCode: "unsupported_host",
     limitations: Object.freeze([
         ...capability.limitations,
         ...windowsP0Limitations,

package/dist/ghidra/GhidraSocketConnection.js

@@ -76,7 +76,7 @@ const connectGhidraSocketOnce = (target, signal) => new Promise((resolve) => {
     if (signal.aborted)
         onAbort();
 });
-const interruptionFailure = (options) => options.deadline.cancelled
+const interruptionFailure = (options) => options.deadline.interruption === "cancelled"
     ? options.failure("cancelled", "Ghidra startup was cancelled")
     : options.failure("timeout", "Ghidra startup deadline elapsed", undefined, {
         timeoutMs: options.startupTimeoutMs,

package/dist/ghidra/protocol.js

@@ -1,46 +1,23 @@
 import { z } from "zod";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
-const responseSchema = z
-    .object({
-    id: z.number().int().positive(),
-    ok: z.boolean(),
-    result: jsonValueSchema.optional(),
-    error: z
-        .object({
-        code: z.string().min(1).max(128),
-        message: z.string().min(1).max(4_096),
-    })
-        .strict()
-        .optional(),
-})
-    .strict()
-    .superRefine((value, context) => {
-    if (value.ok && value.result === undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["result"],
-            message: "Successful Ghidra response requires a result",
-        });
-    if (!value.ok && value.error === undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["error"],
-            message: "Failed Ghidra response requires an error",
-        });
-    if (!value.ok && value.result !== undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["result"],
-            message: "Failed Ghidra response cannot include a result",
-        });
-    if (value.ok && value.error !== undefined)
-        context.addIssue({
-            code: "custom",
-            path: ["error"],
-            message: "Successful Ghidra response cannot include an error",
-        });
-});
+const responseSchema = z.discriminatedUnion("ok", [
+    z.strictObject({
+        id: z.number().int().positive(),
+        ok: z.literal(true),
+        result: jsonValueSchema,
+    }),
+    z.strictObject({
+        id: z.number().int().positive(),
+        ok: z.literal(false),
+        error: z
+            .object({
+            code: z.string().min(1).max(128),
+            message: z.string().min(1).max(4_096),
+        })
+            .strict(),
+    }),
+]);
 /** Expected operation failure returned by the authenticated Java bridge. */
 export class GhidraRemoteError extends Error {
     code;
@@ -65,5 +42,5 @@ export const parseGhidraResponseLine = (line) => {
 };
 /** Project one validated response into its result or remote failure. */
 export const ghidraResponseResult = (response) => response.ok
-    ? ok(response.result ?? null)
-    : err(new GhidraRemoteError(response.error?.code ?? "bridge_error", response.error?.message ?? "Ghidra bridge request failed"));
+    ? ok(response.result)
+    : err(new GhidraRemoteError(response.error.code, response.error.message));

package/dist/hopper/BridgeLauncher.js

@@ -99,7 +99,9 @@ export class HopperApplicationLauncher {
                 process: child,
                 ownsProcessLifetime: true,
                 ownership: started.ownership,
-                shutdownByCleanup: ownsProcessLifetime,
+                shutdownMode: ownsProcessLifetime
+                    ? "process-cleanup"
+                    : "bridge-request",
                 cleanup: () => cleanupOwnedProcessGroup(started.ownership),
             });
         }

package/dist/hopper/HopperAnalysisProfile.js

@@ -49,9 +49,9 @@ export const resolveHopperAnalysisProfile = async (target, options) => {
 export const hopperLoaderArgsForTarget = (target) => {
     if (target.kind === "database")
         return ok([]);
-    const architecture = target.architecture;
-    if (architecture === undefined)
+    if (target.kind !== "executable")
         return err(new ProviderAdapterError("hopper", "resolve_analysis_profile"));
+    const architecture = target.architecture;
     const flag = hopperArchitectureFlag(architecture);
     switch (target.format) {
         case "mach-o":
@@ -62,8 +62,6 @@ export const hopperLoaderArgsForTarget = (target) => {
             return ok(["-l", "ELF", flag]);
         case "pe":
             return ok(["-l", "WinPE", flag]);
-        default:
-            return err(new ProviderAdapterError("hopper", "resolve_analysis_profile"));
     }
 };
 const hopperArchitectureFlag = (architecture) => {

package/dist/hopper/HopperCleanup.js

@@ -10,7 +10,6 @@ export const cleanupHopperSession = async (input) => {
         resources: new Set(),
         cleanupResult: undefined,
         shutdownConfirmed: false,
-        ownedProcessStopped: false,
     };
     await report(input.progress, 0, "requesting Hopper document shutdown");
     await requestShutdown(input, state);
@@ -38,8 +37,7 @@ const requestShutdown = async (input, state) => {
         .catch(() => err(new HopperProcessError(null)));
     if (shutdown.ok &&
         isHopperCleanupRequired(shutdown.value) &&
-        input.launch?.shutdownByCleanup === true &&
-        input.launch.cleanup !== undefined) {
+        input.launch?.shutdownMode === "process-cleanup") {
         state.cleanupResult = await input.launch
             .cleanup()
             .catch(providerCleanupFailure);
@@ -82,7 +80,9 @@ const stopProcess = async (input, state) => {
     }
     input.logger.info(diagnostic, "Owned Hopper launcher shutdown completed");
     if (stopped.status !== "incomplete") {
-        state.ownedProcessStopped = stopped.status !== "not-owned";
+        if (input.launch?.shutdownMode === "process-cleanup" &&
+            stopped.status !== "not-owned")
+            state.shutdownConfirmed = true;
         return;
     }
     const processGroupId = supervisor.launch.ownership?.processGroupId;
@@ -95,8 +95,7 @@ const stopProcess = async (input, state) => {
 };
 const recordUnconfirmedDocument = (input, state) => {
     if ((input.socket === undefined && input.launch === undefined) ||
-        state.shutdownConfirmed ||
-        state.ownedProcessStopped)
+        state.shutdownConfirmed)
         return;
     state.resources.add("hopper-document");
     state.issues.push({