rea-agents 4.0.0 → 4.1.0

package/dist/application/ReferenceSourceImportEntries.js

@@ -48,6 +48,8 @@ const failedEntry = (entry) => {
     };
 };
 const resolveInternalSpecifier = (fromPath, specifier, filePaths) => {
+    if (posix.isAbsolute(specifier))
+        return { to: specifier, resolution: "unresolved" };
     const normalized = posix.normalize(posix.join(posix.dirname(fromPath), specifier));
     if (normalized.startsWith("../") || normalized === "..")
         return { to: normalized, resolution: "unresolved" };

package/dist/application/ReferenceSourceImportPolicy.js

@@ -15,7 +15,8 @@ const resolveRoot = async (requestedRoot) => {
         const canonicalRoot = await realpath(resolve(requestedRoot));
         return ok(canonicalRoot);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return err(failure("invalid-root", "Reference source root could not be resolved"));
     }
 };
@@ -24,8 +25,9 @@ const buildIgnored = async (root, excludePaths) => {
     try {
         ignored.add(await readFile(join(root, ".gitignore"), "utf8"));
     }
-    catch {
+    catch (cause) {
         // Missing or unreadable ignore file does not authorize broader access.
+        void cause;
     }
     ignored.add([...DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS]);
     for (const path of excludePaths) {

package/dist/application/ReferenceSourceVcsAdapter.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
-import { lstat } from "node:fs/promises";
-import { join } from "node:path";
+import { lstat, readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { resolveRef } from "isomorphic-git";
 /**
  * Read Git metadata for a directory using isomorphic-git.
@@ -19,15 +19,46 @@ export const readReferenceSourceVcs = async (root, signal) => {
             : { kind: "unknown", head: null, dirty: null };
     }
     try {
-        const head = await resolveRef({ fs, dir: root, ref: "HEAD" });
+        const head = await resolveSourceHead(root);
         if (isAborted(signal))
             return { kind: "unknown", head: null, dirty: null };
         return { kind: "git", head, dirty: null };
     }
-    catch {
+    catch (cause) {
+        // Unresolvable refs mean VCS state is unknown, not absent.
+        void cause;
         return { kind: "unknown", head: null, dirty: null };
     }
 };
+const resolveSourceHead = async (root) => {
+    const dotgit = join(root, ".git");
+    if (!(await lstat(dotgit)).isFile())
+        return resolveRef({ fs, dir: root, ref: "HEAD" });
+    const pointer = (await readFile(dotgit, "utf8")).replace(/\r?\n$/u, "");
+    if (!pointer.startsWith("gitdir: ") || pointer.length === 8)
+        throw new Error("Invalid Git directory pointer");
+    const gitdir = resolve(root, pointer.slice(8));
+    let commonDirectory;
+    try {
+        commonDirectory = resolve(gitdir, (await readFile(join(gitdir, "commondir"), "utf8")).replace(/\r?\n$/u, ""));
+    }
+    catch (cause) {
+        if (errorCode(cause) !== "ENOENT")
+            throw cause;
+        return resolveRef({ fs, dir: root, gitdir, ref: "HEAD" });
+    }
+    const head = (await readFile(join(gitdir, "HEAD"), "utf8")).trim();
+    if (!head.startsWith("ref: "))
+        return resolveRef({ fs, dir: root, gitdir, ref: "HEAD" });
+    const ref = head.slice(5);
+    const privateRef = ["refs/bisect/", "refs/rewritten/", "refs/worktree/"].some((prefix) => ref.startsWith(prefix));
+    return resolveRef({
+        fs,
+        dir: root,
+        gitdir: privateRef ? gitdir : commonDirectory,
+        ref,
+    });
+};
 const errorCode = (cause) => typeof cause === "object" && cause !== null && "code" in cause
     ? String(cause.code)
     : undefined;

package/dist/application/SessionProviderRouter.js

@@ -1,5 +1,8 @@
 import { analysisProfileSchema, } from "../domain/analysisProfile.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, ProviderAdapterError, ProviderSelectionError, } from "../domain/errors.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderSelectionError } from "../domain/providerSelectionError.js";
+import {} from "../domain/analysisErrorBase.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { err, ok } from "../domain/result.js";
 import { AnalysisProviderRegistry, } from "./AnalysisProviderRegistry.js";

package/dist/application/Setup.js

@@ -1,47 +1,6 @@
-import { access } from "node:fs/promises";
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-import { PRODUCT_IDENTITY } from "../identity.js";
-import { supportsNodeVersion } from "../domain/runtimeVersion.js";
-import { runDoctor, systemDoctorHost, } from "./Doctor.js";
-import { installLinuxHopper, readLinuxDistribution, } from "./LinuxHopper.js";
-import { installMacHopper } from "./MacHopper.js";
 import { configureDetectedClients } from "./SetupClients.js";
-import { supportedClients } from "./SupportedClients.js";
-import { canonicalSkillNeedsInstall, installCanonicalSkill, } from "./SetupSkill.js";
 import { discoverSetupState, planSetupActions } from "./SetupPlan.js";
-import { clientConfigurationAligned, configureClientConfiguration, configureJsonClient, configureTomlClient, inspectClientConfiguration, } from "./SetupClientConfiguration.js";
-export { configureJsonClient, configureTomlClient };
-import { setupInstallFailure, } from "./SetupInstallFailure.js";
-import { providerRegistrationEnvironment } from "./SetupRegistrationEnvironment.js";
-export { canonicalSkillNeedsInstall, installCanonicalSkill };
-/** Resolve the executable and arguments used in a managed MCP registration. */
-export const setupRegistrationCommand = (platform, useNpmRunner = process.env.npm_command === "exec") => useNpmRunner
-    ? PRODUCT_IDENTITY.mcpCommand.split(" ")
-    : platform === "win32"
-        ? [
-            process.execPath,
-            resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary),
-            "mcp",
-        ]
-        : [resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary), "mcp"];
-/** Whether the requested setup actions still need approval or human repair. */
-export const isSetupFailure = (result) => {
-    const status = result.status;
-    switch (status) {
-        case "planned":
-        case "cancelled":
-        case "ready":
-            return false;
-        case "needs_confirmation":
-        case "needs_human":
-            return true;
-        default: {
-            const exhaustive = status;
-            throw new TypeError(`Unhandled setup result status: ${String(exhaustive)}`);
-        }
-    }
-};
+import { filterClientsNeedingConfigure, hostRemediation, initialProviderEnvironment, setupRegistrationCommand, systemSetupHost, } from "./SetupHost.js";
 /** Discover, approve, and apply setup actions idempotently. */
 export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     const appliedActions = [];
@@ -310,14 +269,6 @@ const setupFailure = async (remediation, [host, plannedActions, appliedActions,
     };
 };
 const emitProgress = (options, event) => options.onProgress?.(event);
-const filterClientsNeedingConfigure = async (host, detectedClients, providerEnvironment, command) => {
-    const needs = await Promise.all(detectedClients.map((client) => host.clientNeedsConfigure(client, providerEnvironment, command)));
-    return detectedClients.filter((_, index) => needs[index]);
-};
-const initialProviderEnvironment = async (host, hopperPath) => ({
-    ...(await host.providerEnvironment?.()),
-    ...(hopperPath === undefined ? {} : { HOPPER_LAUNCHER_PATH: hopperPath }),
-});
 const finalSetupRemediation = (platform, installedHopper, healthy, hopperPath) => {
     if (platform === "darwin" && installedHopper)
         return "Open Hopper, choose its demo mode or activate a license, then rerun rea doctor --json.";
@@ -371,81 +322,3 @@ const summarizeDoctor = (report) => ({
             },
         }),
 });
-const hostRemediation = async (host, installHopper) => {
-    if (!supportsNodeVersion(host.nodeVersion))
-        return "Install Node.js 22.19+ or 24.11+ and rerun setup.";
-    if (!installHopper)
-        return undefined;
-    if (host.platform !== "darwin" && host.platform !== "linux")
-        return "REA supports Hopper on macOS and selected 64-bit Linux distributions.";
-    if (host.platform === "darwin") {
-        const version = await host.macosVersion();
-        return version === undefined || major(version) < 12
-            ? "Upgrade to macOS 12 or newer."
-            : undefined;
-    }
-    if ((await host.linuxDistribution())?.supported === true)
-        return undefined;
-    return "Automated Hopper setup supports Ubuntu 24.04+, Fedora 41+, and 64-bit Arch Linux; configure an existing supported provider instead.";
-};
-/** Production setup effects for Hopper, agent configuration, and the canonical skill directory. */
-export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
-    const platform = doctorHost.platform;
-    return {
-        platform,
-        nodeVersion: process.versions.node,
-        macosVersion: () => doctorHost.macosVersion(),
-        linuxDistribution: readLinuxDistribution,
-        hopperPath: async () => (await runDoctor(undefined, doctorHost)).hopperPath,
-        providerEnvironment: async () => {
-            const diagnosis = await runDoctor(undefined, doctorHost);
-            return {
-                ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
-                ...(diagnosis.hopperPath === undefined
-                    ? {}
-                    : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),
-            };
-        },
-        installHopper: async (replaceExisting) => {
-            const result = platform === "linux"
-                ? await installLinuxHopper()
-                : await installMacHopper({ replaceExisting });
-            if (result.status === "installed")
-                return result;
-            return setupInstallFailure(result.reason);
-        },
-        detectedClients: () => detectClients(homedir()),
-        supportedClients: () => Promise.resolve(supportedClients(homedir())),
-        configureClient: (client, providerEnvironment, command) => client.format === "unsupported"
-            ? Promise.resolve({ status: "skipped" })
-            : configureClientConfiguration(client, providerEnvironment, command),
-        clientNeedsConfigure: (client, providerEnvironment, command) => clientConfigurationAligned(client, providerEnvironment, command).then((aligned) => !aligned),
-        inspectClientConfiguration: inspectClientConfiguration,
-        skillNeedsInstall: () => canonicalSkillNeedsInstall(homedir()),
-        installSkill: () => installCanonicalSkill(homedir()),
-        doctor: (scope) => runDoctor(undefined, doctorHost, scope),
-    };
-};
-/** Detect supported agents from their config files or stable installation markers. */
-export const detectClients = async (home) => {
-    const detected = [];
-    for (const candidate of supportedClients(home)) {
-        const [hasConfig, hasMarker] = await Promise.all([
-            exists(candidate.configPath),
-            candidate.markerPath === undefined ? false : exists(candidate.markerPath),
-        ]);
-        if (hasConfig || hasMarker)
-            detected.push(candidate);
-    }
-    return detected;
-};
-const major = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
-const exists = async (path) => {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};

package/dist/application/SetupClientConfiguration.js

@@ -38,7 +38,9 @@ const configureClientDocument = async (client, environment, command, format) =>
     try {
         parsed = parseClientConfiguration(original ?? (format === "toml" ? "" : "{}"), format);
     }
-    catch {
+    catch (cause) {
+        // Malformed existing configuration fails the readback gate.
+        void cause;
         return { status: "failed", reason: "readback" };
     }
     const { document, servers, serversKey } = parsed;
@@ -60,7 +62,9 @@ const configureClientDocument = async (client, environment, command, format) =>
             mode: 0o600,
         });
     }
-    catch {
+    catch (cause) {
+        // Write failure is reported by the status reason.
+        void cause;
         return { status: "failed", reason: "write" };
     }
     try {
@@ -70,7 +74,9 @@ const configureClientDocument = async (client, environment, command, format) =>
             return { status: "failed", reason: "readback" };
         }
     }
-    catch {
+    catch (cause) {
+        // Readback failure restores the transaction before reporting.
+        void cause;
         await restoreConfig(transactionPath, original);
         return { status: "failed", reason: "readback" };
     }
@@ -87,7 +93,9 @@ export const clientConfigurationAligned = async (client, providerEnvironment, co
         const { servers } = parseClientConfiguration(original, client.format);
         return clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired);
     }
-    catch {
+    catch (cause) {
+        // Unreadable configuration is treated as not aligned so setup repairs it.
+        void cause;
         return false;
     }
 };
@@ -119,7 +127,9 @@ export const inspectClientConfiguration = async (client, providerEnvironment, co
         if (clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
             return { status: "already_current" };
     }
-    catch {
+    catch (cause) {
+        // Malformed configuration is reported with the invalid remediation.
+        void cause;
         return {
             status: "invalid",
             remediation: "The existing configuration is malformed. Repair it before setup applies any other changes.",
@@ -147,8 +157,9 @@ const restoreConfig = async (path, original) => {
         else
             await writeFile(path, original, { encoding: "utf8", mode: 0o600 });
     }
-    catch {
+    catch (cause) {
         // The backup remains available for the remediation reported by setup.
+        void cause;
     }
 };
 const clientConfigurationDesired = (client, providerEnvironment, command, format) => {

package/dist/application/SetupHost.js

@@ -0,0 +1,111 @@
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { PRODUCT_IDENTITY } from "../identity.js";
+import { supportsNodeVersion } from "../domain/runtimeVersion.js";
+import { runDoctor, systemDoctorHost } from "./Doctor.js";
+import { installLinuxHopper, readLinuxDistribution } from "./LinuxHopper.js";
+import { installMacHopper } from "./MacHopper.js";
+import { supportedClients } from "./SupportedClients.js";
+import { canonicalSkillNeedsInstall, installCanonicalSkill, } from "./SetupSkill.js";
+import { clientConfigurationAligned, configureClientConfiguration, inspectClientConfiguration, } from "./SetupClientConfiguration.js";
+import { setupInstallFailure } from "./SetupInstallFailure.js";
+import { providerRegistrationEnvironment } from "./SetupRegistrationEnvironment.js";
+/** Resolve the executable and arguments used in a managed MCP registration. */
+export const setupRegistrationCommand = (platform, useNpmRunner = process.env.npm_command === "exec") => useNpmRunner
+    ? PRODUCT_IDENTITY.mcpCommand.split(" ")
+    : platform === "win32"
+        ? [
+            process.execPath,
+            resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary),
+            "mcp",
+        ]
+        : [resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary), "mcp"];
+export const filterClientsNeedingConfigure = async (host, detectedClients, providerEnvironment, command) => {
+    const needs = await Promise.all(detectedClients.map((client) => host.clientNeedsConfigure(client, providerEnvironment, command)));
+    return detectedClients.filter((_, index) => needs[index]);
+};
+export const initialProviderEnvironment = async (host, hopperPath) => ({
+    ...(await host.providerEnvironment?.()),
+    ...(hopperPath === undefined ? {} : { HOPPER_LAUNCHER_PATH: hopperPath }),
+});
+export const hostRemediation = async (host, installHopper) => {
+    if (!supportsNodeVersion(host.nodeVersion))
+        return "Install Node.js 22.x (>=22.19), 24.x (>=24.11), or 26+ and rerun setup.";
+    if (!installHopper)
+        return undefined;
+    if (host.platform !== "darwin" && host.platform !== "linux")
+        return "REA supports Hopper on macOS and selected 64-bit Linux distributions.";
+    if (host.platform === "darwin") {
+        const version = await host.macosVersion();
+        return version === undefined || major(version) < 12
+            ? "Upgrade to macOS 12 or newer."
+            : undefined;
+    }
+    if ((await host.linuxDistribution())?.supported === true)
+        return undefined;
+    return "Automated Hopper setup supports Ubuntu 24.04+, Fedora 41+, and 64-bit Arch Linux; configure an existing supported provider instead.";
+};
+/** Production setup effects for Hopper, agent configuration, and the canonical skill directory. */
+export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
+    const platform = doctorHost.platform;
+    return {
+        platform,
+        nodeVersion: process.versions.node,
+        macosVersion: () => doctorHost.macosVersion(),
+        linuxDistribution: readLinuxDistribution,
+        hopperPath: async () => (await runDoctor(undefined, doctorHost)).hopperPath,
+        providerEnvironment: async () => {
+            const diagnosis = await runDoctor(undefined, doctorHost);
+            return {
+                ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
+                ...(diagnosis.hopperPath === undefined
+                    ? {}
+                    : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),
+            };
+        },
+        installHopper: async (replaceExisting) => {
+            const result = platform === "linux"
+                ? await installLinuxHopper()
+                : await installMacHopper({ replaceExisting });
+            if (result.status === "installed")
+                return result;
+            return setupInstallFailure(result.reason);
+        },
+        detectedClients: () => detectClients(homedir()),
+        supportedClients: () => Promise.resolve(supportedClients(homedir())),
+        configureClient: (client, providerEnvironment, command) => client.format === "unsupported"
+            ? Promise.resolve({ status: "skipped" })
+            : configureClientConfiguration(client, providerEnvironment, command),
+        clientNeedsConfigure: (client, providerEnvironment, command) => clientConfigurationAligned(client, providerEnvironment, command).then((aligned) => !aligned),
+        inspectClientConfiguration: inspectClientConfiguration,
+        skillNeedsInstall: () => canonicalSkillNeedsInstall(homedir()),
+        installSkill: () => installCanonicalSkill(homedir()),
+        doctor: (scope) => runDoctor(undefined, doctorHost, scope),
+    };
+};
+/** Detect supported agents from their config files or stable installation markers. */
+export const detectClients = async (home) => {
+    const detected = [];
+    for (const candidate of supportedClients(home)) {
+        const [hasConfig, hasMarker] = await Promise.all([
+            exists(candidate.configPath),
+            candidate.markerPath === undefined ? false : exists(candidate.markerPath),
+        ]);
+        if (hasConfig || hasMarker)
+            detected.push(candidate);
+    }
+    return detected;
+};
+const major = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
+const exists = async (path) => {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (cause) {
+        // best-effort cleanup: optional host probing; absence means unavailable.
+        void cause;
+        return false;
+    }
+};

package/dist/application/SetupRegistrationEnvironment.js

@@ -1,5 +1,4 @@
-/** Select exact non-secret settings published by available providers. */
+/** Preserve adapter-published settings independently of runtime readiness. */
 export const providerRegistrationEnvironment = (inspections) => Object.fromEntries(inspections
-    .filter(({ available }) => available)
     .flatMap(({ registrationEnvironment }) => Object.entries(registrationEnvironment))
     .sort(([left], [right]) => left.localeCompare(right)));

package/dist/application/SetupSkill.js

@@ -6,6 +6,7 @@ const SKILL_FILES = [
     "SKILL.md",
     "references/native-and-artifacts.md",
     "references/javascript-applications.md",
+    "references/android-applications.md",
     "references/runtime-observation.md",
     "references/evidence-workflows.md",
 ];
@@ -33,7 +34,9 @@ export const canonicalSkillNeedsInstall = async (home) => {
     try {
         return (await canonicalSkillFiles(home)).some(({ content, original }) => original !== content);
     }
-    catch {
+    catch (cause) {
+        // Unreadable skill state fails open to install so setup can repair it.
+        void cause;
         return true;
     }
 };
@@ -66,12 +69,15 @@ export const installCanonicalSkill = async (home) => {
                 throw new Error(`skill readback mismatch: ${destination}`);
         return "installed";
     }
-    catch {
+    catch (cause) {
+        // Install failure preserves the original error outcome; report cause inline.
+        void cause;
         try {
             await restoreSkillFiles(changed);
         }
-        catch {
+        catch (restoreCause) {
             // Per-file backups remain beside changed files for operator recovery.
+            void restoreCause;
         }
         return "failed";
     }

package/dist/application/SetupTypes.js

@@ -0,0 +1,17 @@
+/** Whether the requested setup actions still need approval or human repair. */
+export const isSetupFailure = (result) => {
+    const status = result.status;
+    switch (status) {
+        case "planned":
+        case "cancelled":
+        case "ready":
+            return false;
+        case "needs_confirmation":
+        case "needs_human":
+            return true;
+        default: {
+            const exhaustive = status;
+            throw new TypeError(`Unhandled setup result status: ${String(exhaustive)}`);
+        }
+    }
+};

package/dist/application/StoreFileLock.js

@@ -34,7 +34,10 @@ export const createStoreFileLock = async (path) => {
         }
         return {
             release: async () => {
-                await removeOwner(path, owner).catch(() => undefined);
+                await removeOwner(path, owner).catch((cause) => {
+                    // best-effort cleanup: lock release must not reject unhandled.
+                    void cause;
+                });
             },
         };
     }
@@ -68,7 +71,9 @@ export const removeStaleStoreFileLock = async (path) => {
         await removeOwner(path, owner);
         return true;
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: stale lock probing; failure means the lock stands.
+        void cause;
         return false;
     }
 };

package/dist/application/SupportedClients.js

@@ -18,6 +18,7 @@ const claudeCodeConfigDirectory = ({ home, env }) => env.CLAUDE_CONFIG_DIR ?? ho
 const claudeCodeMarkerDirectory = ({ home, env }) => env.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
 const codexDirectory = ({ home, env }) => env.CODEX_HOME ?? join(home, ".codex");
 const copilotDirectory = ({ home, env }) => env.COPILOT_HOME ?? join(home, ".copilot");
+const commandCodeDirectory = ({ home }) => join(home, ".commandcode");
 const opencodeDirectory = ({ home, env }) => join(env.XDG_CONFIG_HOME ?? join(home, ".config"), "opencode");
 const existingOpenCodeConfigPath = (context) => {
     if (context.env.OPENCODE_CONFIG !== undefined)
@@ -118,6 +119,13 @@ export const SUPPORTED_CLIENT_DEFINITIONS = [
         markerPath: copilotDirectory,
         format: "copilot_cli",
     },
+    {
+        name: "commandcode",
+        displayName: "Command Code",
+        configPath: (context) => join(commandCodeDirectory(context), "mcp.json"),
+        markerPath: commandCodeDirectory,
+        format: "commandcode",
+    },
     {
         name: "vscode",
         displayName: "VS Code",

package/dist/application/Uninstall.js

@@ -86,7 +86,8 @@ const removeClient = async (client, fileSystem) => {
             serversKey: key,
         } = parseClientConfiguration(original, client.format));
     }
-    catch {
+    catch (cause) {
+        void cause;
         return item(client.name, "failed", `Configuration is not valid ${client.format === "toml" ? "TOML" : client.format === "opencode" ? "JSONC" : "JSON"} and was not changed. Repair it, then rerun uninstall.`);
     }
     const registration = servers[PRODUCT_IDENTITY.mcpServerKey];
@@ -101,7 +102,8 @@ const removeClient = async (client, fileSystem) => {
     try {
         await fileSystem.copy(transactionPath, backupPath);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return item(client.name, "failed", "Configuration could not be backed up, so no change was made. Check file permissions, then rerun uninstall.");
     }
     try {
@@ -111,11 +113,14 @@ const removeClient = async (client, fileSystem) => {
             throw new Error("registration readback mismatch");
         return item(client.name, "removed", `Removed registration from ${client.configPath}.`);
     }
-    catch {
+    catch (cause) {
+        // Update failure attempts a restore before reporting; cause is preserved below.
+        void cause;
         try {
             await fileSystem.writeText(transactionPath, original);
         }
-        catch {
+        catch (restoreCause) {
+            void restoreCause;
             return item(client.name, "failed", "Configuration could not be updated or restored. Restore its `.rea.backup` manually, then rerun uninstall.");
         }
         return item(client.name, "failed", "Configuration could not be updated. The original was restored and its `.rea.backup` was retained. Repair the configuration or restore the backup, then rerun uninstall.");

package/dist/application/UpdateRuntime.js

@@ -58,7 +58,9 @@ export const detectNpmInstallation = async (packageRoot, host) => {
     try {
         canonicalPackageRoot = await host.canonicalPath(packageRoot);
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: optional install-location probing; unknown means not npm-managed.
+        void cause;
         return undefined;
     }
     try {
@@ -71,8 +73,9 @@ export const detectNpmInstallation = async (packageRoot, host) => {
                 : { prefix, packageRoot: canonicalPackageRoot };
         }
     }
-    catch {
+    catch (cause) {
         // The curl installer uses a Unix prefix that may differ from npm's current default.
+        void cause;
     }
     const nodeModules = dirname(canonicalPackageRoot);
     const library = dirname(nodeModules);

package/dist/application/WindowsCapabilities.js

@@ -22,7 +22,8 @@ export const probeWindowsCapabilities = async (dependencies = systemDependencies
                 ? { available: true, reason: null }
                 : { available: false, reason: pty.reason },
         },
-        security: windowsNativeCapabilities(dependencies.platform),
+        security: dependencies.nativeCapabilities?.() ??
+            windowsNativeCapabilities(dependencies.platform),
     };
 };
 const systemDependencies = () => ({
@@ -30,10 +31,8 @@ const systemDependencies = () => ({
     architecture: process.arch,
     probeSymlinkCreation,
     probeNoFollowOpen: () => systemNoFollowOpenCapability(process.platform, constants.O_NOFOLLOW),
-    probePrivateAcl: () => ({
-        available: false,
-        reason: "Windows ACL enforcement is not implemented by this REA build",
-    }),
+    probePrivateAcl: () => windowsNativeCapabilities(process.platform).private_runtime_dacl,
+    nativeCapabilities: () => windowsNativeCapabilities(process.platform),
     probeUnixDomainSocket: () => process.platform === "win32"
         ? {
             available: false,
@@ -47,7 +46,7 @@ export const systemNoFollowOpenCapability = (platform, noFollow) => {
     if (platform === "win32")
         return {
             available: false,
-            reason: "Windows reparse-safe handle admission is not implemented",
+            reason: "Node pathname O_NOFOLLOW is not Windows handle authority; native admission is reported separately in security.",
         };
     return typeof noFollow === "number"
         ? { available: true, reason: null }
@@ -79,9 +78,10 @@ const probeSymlinkCreation = async () => {
         try {
             await rm(root, { recursive: true, force: true });
         }
-        catch {
+        catch (cause) {
             // Cleanup failure must not replace the machine-readable probe outcome.
             // The probe root lives beneath the OS temporary directory and is unique.
+            void cause;
         }
     }
 };

package/dist/application/runtime.js

@@ -1,5 +1,6 @@
 import { HopperProvider } from "../hopper/HopperProvider.js";
 import { GhidraProvider } from "../ghidra/GhidraProvider.js";
+import { IdaProvider } from "../ida/IdaProvider.js";
 import { silentLogger } from "../logger.js";
 import { GENERATED_AUXILIARY_PROVIDERS } from "../generatedMcpToolCatalog.js";
 import { AnalysisProviderRegistry } from "./AnalysisProviderRegistry.js";
@@ -16,6 +17,7 @@ import { SessionProviderRouter } from "./SessionProviderRouter.js";
 export const createBinarySession = (config, logger = silentLogger) => {
     const hopper = new HopperProvider(config, logger);
     const ghidra = new GhidraProvider(config, logger);
+    const ida = new IdaProvider(config);
     const auxiliary = new Map(GENERATED_AUXILIARY_PROVIDERS.map((provider) => [
         provider.identity.id,
         provider,
@@ -30,7 +32,7 @@ export const createBinarySession = (config, logger = silentLogger) => {
             load,
         });
     };
-    return composeBinarySession(new AnalysisProviderRegistry([hopper, ghidra], config.analysisProvider), [
+    return composeBinarySession(new AnalysisProviderRegistry([hopper, ghidra, ida], config.analysisProvider), [
         lazyProvider("rea-artifact-graph", async () => {
             const { ArtifactProvider } = await import("../artifacts/ArtifactProvider.js");
             return new ArtifactProvider();