rea-agents 1.7.0 → 2.1.0

package/dist/application/Doctor.js

@@ -1,94 +1,27 @@
 import { constants } from "node:fs";
 import { access, readFile, readdir } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { delimiter, join } from "node:path";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { parseBinaryTarget } from "../domain/binaryTarget.js";
-import { supportsNodeVersion } from "../domain/runtimeVersion.js";
 import { probeHomebrew } from "./homebrew.js";
-import { linuxHopperBinarySupported, linuxHopperLauncherPath, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
+import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
 import { CATALOG_IDENTITY } from "../catalogIdentity.js";
 import { PRODUCT_IDENTITY, SDK_IDENTITY } from "../identity.js";
 import { readClientRegistrationStatuses, } from "./ClientRegistrationStatus.js";
+import { inspectRuntimeExecutables, } from "./RuntimeExecutableDiagnostics.js";
+import { collectDoctorDiagnostics, doctorHealthy, } from "./DoctorDiagnostics.js";
 const execFileAsync = promisify(execFile);
-const DEFAULT_HOPPER = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
-const SYSTEM_LINUX_HOPPER = "/opt/hopper/bin/Hopper";
 /**
  * Check requirements and an optional target without mutating the host.
  * Every failed check includes remediation suitable for either the one-shot CLI
  * or an agent consuming the structured result.
  */
 export const runDoctor = async (target, host = systemDoctorHost()) => {
-    const checks = [];
-    checks.push(check("node", supportsNodeVersion(host.nodeVersion), host.nodeVersion, {
-        remediation: "Install Node.js 22.19+ or 24.11+.",
-        classification: "missing_dependency",
-    }));
-    const macosVersion = host.platform === "darwin" ? await host.macosVersion() : undefined;
-    const macosMajor = macosVersion === undefined ? 0 : parseMajor(macosVersion);
-    const linuxDistribution = host.platform === "linux" ? await host.linuxDistribution() : undefined;
-    const supportedHost = (host.platform === "darwin" && macosMajor >= 12) ||
-        (host.platform === "linux" && linuxDistribution?.supported === true);
-    checks.push(check("host", supportedHost, macosVersion ??
-        (linuxDistribution === undefined
-            ? host.platform
-            : `${linuxDistribution.id} ${linuxDistribution.versionId ?? "unknown"}`), {
-        remediation: "REA supports macOS 12+, Ubuntu 24.04+, Fedora 41+, and 64-bit Arch Linux.",
-        classification: "unsupported_host",
-    }));
-    const candidates = host.configuredHopperPath === undefined
-        ? [
-            DEFAULT_HOPPER,
-            SYSTEM_LINUX_HOPPER,
-            linuxHopperLauncherPath(homedir()),
-            ...(await host.manualHopperPaths()),
-            await host.brewHopperPath(),
-        ].filter((value) => value !== undefined)
-        : [host.configuredHopperPath];
-    let hopperPath;
-    for (const candidate of new Set(candidates))
-        if (await host.executable(candidate)) {
-            hopperPath = candidate;
-            break;
-        }
-    checks.push(check("hopper", hopperPath !== undefined, hopperPath ?? host.configuredHopperPath, {
-        remediation: host.configuredHopperPath === undefined
-            ? "Run rea setup to install Hopper, or set HOPPER_LAUNCHER_PATH."
-            : "Unset or update HOPPER_LAUNCHER_PATH to an executable Hopper launcher.",
-        classification: host.configuredHopperPath === undefined
-            ? "missing_analysis_engine"
-            : "config_drift",
-    }));
-    if (host.platform === "linux" && hopperPath !== undefined)
-        checks.push(check("hopper-version", await host.supportedLinuxHopper(hopperPath), hopperPath, {
-            remediation: unsupportedHopperRemediation(host.configuredHopperPath === hopperPath),
-            classification: "config_drift",
-        }));
-    const providerInspections = await inspectDoctorProviders(host, checks);
-    if (host.platform === "linux" && hopperPath !== undefined)
-        checks.push(check("hopper-demo-runtime", await host.linuxDemoRuntimeReady(), undefined, {
-            remediation: "Rerun rea setup to install the Xvfb, xauth, Python, X11, and XTEST packages required for Linux demo sessions.",
-            classification: "missing_dependency",
-        }));
-    if (target !== undefined)
-        checks.push(check("target", await host.validTarget(target), target, {
-            remediation: "Supply a readable local app or program path.",
-            classification: "config_drift",
-        }));
-    const installationPaths = (await host.installationPaths?.()) ?? [];
-    const installedSkillVersion = await host.installedSkillVersion?.();
-    const registrations = (await host.clientRegistrations?.()) ?? [];
-    for (const registration of registrations)
-        if (registration.state !== "aligned")
-            checks.push({
-                name: `registration:${registration.client}`,
-                ok: false,
-                classification: "config_drift",
-                detail: registration.config_path,
-                remediation: registration.remediation ??
-                    "Run rea setup, then restart the affected client.",
-            });
+    const { checks: diagnosticChecks, hopperPath, providerInspections, runtimeExecutables, } = await collectDoctorDiagnostics(target, host);
+    const identity = await collectDoctorIdentity(host, runtimeExecutables);
+    const checks = [...diagnosticChecks, ...identity.checks];
     return {
         healthy: doctorHealthy(checks, {
             hopperAvailable: hopperPath !== undefined &&
@@ -101,7 +34,22 @@ export const runDoctor = async (target, host = systemDoctorHost()) => {
         ...(hopperPath === undefined ? {} : { hopperPath }),
         ...(providerInspections === undefined ? {} : { providerInspections }),
         checks,
-        identity: {
+        identity: identity.value,
+    };
+};
+const collectDoctorIdentity = async (host, runtimeExecutables) => {
+    const installationPaths = (await host.installationPaths?.()) ?? [];
+    const installedSkillIdentity = await readInstalledSkillIdentity(host);
+    const skillAligned = skillIdentityAligned(installedSkillIdentity);
+    const registrations = (await host.clientRegistrations?.()) ?? [];
+    return {
+        checks: [
+            ...(skillAligned ? [] : [skillIdentityCheck(installedSkillIdentity)]),
+            ...registrations
+                .filter(({ state }) => state !== "aligned")
+                .map(registrationCheck),
+        ],
+        value: {
             cli_package_version: PRODUCT_IDENTITY.packageVersion,
             expected_skill_version: PRODUCT_IDENTITY.skillVersion,
             sdk: SDK_IDENTITY,
@@ -112,79 +60,74 @@ export const runDoctor = async (target, host = systemDoctorHost()) => {
             },
             installations: {
                 paths: installationPaths,
-                state: installationPaths.length === 0
-                    ? "unknown"
-                    : installationPaths.length === 1
-                        ? "single"
-                        : "multiple",
+                state: installationState(installationPaths),
             },
             skill: {
-                installed_version: installedSkillVersion ?? null,
-                state: installedSkillVersion === undefined
-                    ? "unknown"
-                    : installedSkillVersion === PRODUCT_IDENTITY.skillVersion
+                installed_version: installedSkillIdentity?.version ?? null,
+                installed_tool_count: installedSkillIdentity?.toolCount ?? null,
+                installed_catalog_digest: installedSkillIdentity?.catalogDigest ?? null,
+                state: installedSkillIdentity === undefined
+                    ? "missing"
+                    : skillAligned
                         ? "aligned"
                         : "stale",
-                remediation: installedSkillVersion === undefined ||
-                    installedSkillVersion === PRODUCT_IDENTITY.skillVersion
+                remediation: skillAligned
                     ? null
                     : "Run rea setup to update the installed REA skill.",
             },
             registrations,
+            runtime_executables: runtimeExecutables ?? null,
         },
     };
 };
-const unsupportedHopperRemediation = (configured) => configured
-    ? "Unset or update HOPPER_LAUNCHER_PATH, install the Hopper build supported by this REA release, or update REA."
-    : "Install the Hopper build supported by this REA release, or update REA for a newer Hopper build.";
+const readInstalledSkillIdentity = async (host) => {
+    const observed = await host.installedSkillIdentity?.();
+    if (observed !== undefined)
+        return observed;
+    const legacyVersion = await host.installedSkillVersion?.();
+    return legacyVersion === undefined
+        ? undefined
+        : { version: legacyVersion, toolCount: null, catalogDigest: null };
+};
+const skillIdentityAligned = (identity) => identity?.version === PRODUCT_IDENTITY.skillVersion &&
+    identity.toolCount === CATALOG_IDENTITY.counts.mcp_tools &&
+    identity.catalogDigest === CATALOG_IDENTITY.digests.combined_sha256;
+const skillIdentityCheck = (identity) => ({
+    name: "skill:identity",
+    ok: false,
+    classification: "config_drift",
+    detail: identity === undefined
+        ? "Installed REA skill identity is missing."
+        : "Installed REA skill identity is stale.",
+    remediation: "Run rea setup to update the installed REA skill.",
+});
+const registrationCheck = (registration) => ({
+    name: `registration:${registration.client}`,
+    ok: false,
+    classification: "config_drift",
+    detail: registration.config_path,
+    remediation: registration.remediation ??
+        "Run rea setup, then restart the affected client.",
+});
+const installationState = (paths) => paths.length === 0 ? "unknown" : paths.length === 1 ? "single" : "multiple";
 /** Create diagnostics backed by the current process and host commands. */
 export const systemDoctorHost = (options = {}) => ({
     platform: process.platform,
+    architecture: process.arch,
     nodeVersion: process.versions.node,
     ...(process.env.HOPPER_LAUNCHER_PATH === undefined
         ? {}
         : { configuredHopperPath: process.env.HOPPER_LAUNCHER_PATH }),
-    async macosVersion() {
-        try {
-            return (await execFileAsync("sw_vers", ["-productVersion"])).stdout.trim();
-        }
-        catch {
-            return undefined;
-        }
-    },
+    ...(process.env.REA_ILSPY_CMD_PATH === undefined
+        ? {}
+        : { configuredIlspyCmdPath: process.env.REA_ILSPY_CMD_PATH }),
+    macosVersion: readMacosVersion,
     linuxDistribution: readLinuxDistribution,
     async validTarget(path) {
         return (await parseBinaryTarget(path)).ok;
     },
-    async executable(path) {
-        try {
-            await access(path, constants.X_OK);
-            if (process.platform === "linux") {
-                const linked = await execFileAsync("ldd", [path]);
-                if (!linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`))
-                    return false;
-            }
-            return true;
-        }
-        catch {
-            return false;
-        }
-    },
-    async linuxDemoRuntimeReady() {
-        try {
-            await access("/usr/bin/Xvfb", constants.X_OK);
-            await access("/usr/bin/xauth", constants.X_OK);
-            await access("/usr/bin/python3", constants.X_OK);
-            await execFileAsync("/usr/bin/python3", [
-                "-c",
-                "import ctypes; ctypes.CDLL('libX11.so.6'); ctypes.CDLL('libXtst.so.6')",
-            ]);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    },
+    executable: executableAvailable,
+    linuxDemoRuntimeReady,
     supportedLinuxHopper: linuxHopperBinarySupported,
     async brewHopperPath() {
         return probeHomebrew(async (command) => {
@@ -201,25 +144,30 @@ export const systemDoctorHost = (options = {}) => ({
             }
         });
     },
-    async manualHopperPaths() {
-        const roots = ["/Applications", join(homedir(), "Applications")];
-        const paths = [];
-        for (const root of roots) {
-            try {
-                for (const entry of await readdir(root, { withFileTypes: true })) {
-                    if (entry.isDirectory() && /^Hopper.*\.app$/i.test(entry.name))
-                        paths.push(join(root, entry.name, "Contents/MacOS/hopper"));
-                }
-            }
-            catch {
-                // A missing or unreadable optional application directory is not fatal.
-            }
-        }
-        return paths;
-    },
+    manualHopperPaths,
     ...(options.providerInspections === undefined
         ? {}
         : { providerInspections: options.providerInspections }),
+    ...(options.javascriptReplayCheck === undefined
+        ? {}
+        : { javascriptReplayCheck: options.javascriptReplayCheck }),
+    async ilspyCmdVersion(path) {
+        try {
+            await access(path, constants.X_OK);
+            return firstIlspyVersionLine((await execFileAsync(path, ["--version"], { timeout: 10_000 })).stdout);
+        }
+        catch {
+            return undefined;
+        }
+    },
+    runtimeExecutables: () => inspectRuntimeExecutables({
+        platform: process.platform,
+        path: process.env.PATH ?? "",
+        launcherNode: process.execPath,
+        ...(process.env.PATHEXT === undefined
+            ? {}
+            : { pathExtensions: process.env.PATHEXT.split(delimiter) }),
+    }),
     async installationPaths() {
         try {
             const command = process.platform === "win32" ? "where" : "which";
@@ -230,68 +178,88 @@ export const systemDoctorHost = (options = {}) => ({
             return [];
         }
     },
-    async installedSkillVersion() {
+    installedSkillVersion,
+    installedSkillIdentity,
+    clientRegistrations: () => readClientRegistrationStatuses(homedir()),
+});
+const readMacosVersion = async () => {
+    try {
+        return (await execFileAsync("sw_vers", ["-productVersion"])).stdout.trim();
+    }
+    catch {
+        return undefined;
+    }
+};
+const executableAvailable = async (path) => {
+    try {
+        await access(path, constants.X_OK);
+        if (process.platform !== "linux")
+            return true;
+        const linked = await execFileAsync("ldd", [path]);
+        return linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`);
+    }
+    catch {
+        return false;
+    }
+};
+const linuxDemoRuntimeReady = async () => {
+    try {
+        await access("/usr/bin/Xvfb", constants.X_OK);
+        await access("/usr/bin/xauth", constants.X_OK);
+        await access("/usr/bin/python3", constants.X_OK);
+        await execFileAsync("/usr/bin/python3", [
+            "-c",
+            "import ctypes; ctypes.CDLL('libX11.so.6'); ctypes.CDLL('libXtst.so.6')",
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const manualHopperPaths = async () => {
+    const paths = [];
+    for (const root of ["/Applications", join(homedir(), "Applications")]) {
         try {
-            const content = await readFile(join(homedir(), ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"), "utf8");
-            return /^\s{2}version:\s*"([^"]+)"\s*$/mu.exec(content)?.[1];
+            for (const entry of await readdir(root, { withFileTypes: true })) {
+                if (entry.isDirectory() && /^Hopper.*\.app$/i.test(entry.name))
+                    paths.push(join(root, entry.name, "Contents/MacOS/hopper"));
+            }
         }
         catch {
-            return undefined;
+            // A missing or unreadable optional application directory is not fatal.
         }
-    },
-    clientRegistrations: () => readClientRegistrationStatuses(homedir()),
-});
-const parseMajor = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
+    }
+    return paths;
+};
+const readInstalledSkill = () => readFile(join(homedir(), ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"), "utf8");
+const installedSkillVersion = async () => {
+    try {
+        return /^\s{2}version:\s*"([^"]+)"\s*$/mu.exec(await readInstalledSkill())?.[1];
+    }
+    catch {
+        return undefined;
+    }
+};
+const installedSkillIdentity = async () => {
+    try {
+        const content = await readInstalledSkill();
+        const countText = /^\s{2}tool_count:\s*(\d+)\s*$/mu.exec(content)?.[1];
+        return {
+            version: /^\s{2}version:\s*"([^"]+)"\s*$/mu.exec(content)?.[1] ?? null,
+            toolCount: countText === undefined ? null : Number.parseInt(countText, 10),
+            catalogDigest: /^\s{2}catalog_digest:\s*"([a-f0-9]{64})"\s*$/mu.exec(content)?.[1] ??
+                null,
+        };
+    }
+    catch {
+        return undefined;
+    }
+};
 const uniqueLines = (value) => [
     ...new Set(value
         .split(/\r?\n/u)
         .map((line) => line.trim())
         .filter((line) => line.length > 0)),
 ];
-const check = (name, ok, detail, failure) => ({
-    name,
-    ok,
-    classification: ok ? "healthy" : failure.classification,
-    ...(detail === undefined ? {} : { detail }),
-    ...(ok ? {} : { remediation: failure.remediation }),
-});
-const providerDoctorChecks = (inspection) => inspection.checks.map((candidate) => ({
-    name: candidate.name === "configuration"
-        ? inspection.id
-        : `${inspection.id}-${candidate.name}`,
-    ok: candidate.ok,
-    classification: candidate.ok ? "healthy" : candidate.classification,
-    detail: candidate.detail,
-    ...(candidate.remediation === null
-        ? {}
-        : { remediation: candidate.remediation }),
-}));
-const inspectDoctorProviders = async (host, checks) => {
-    const inspections = await host.providerInspections?.();
-    if (inspections === undefined)
-        return undefined;
-    for (const inspection of inspections)
-        checks.push(...providerDoctorChecks(inspection));
-    return inspections;
-};
-const doctorHealthy = (checks, providers) => {
-    if (providers.providerInspections === undefined)
-        return checks.every(({ ok }) => ok);
-    const providerChecks = checks.filter(({ name }) => name.startsWith("hopper") ||
-        providers.providerInspections?.some((inspection) => providerCheckName(inspection.id, name)) === true);
-    const coreHealthy = checks
-        .filter((candidate) => !providerChecks.includes(candidate))
-        .every(({ ok }) => ok);
-    const configuredProvidersHealthy = providerChecks
-        .filter(({ name }) => {
-        if (name.startsWith("hopper"))
-            return providers.hopperConfigured;
-        return providers.providerInspections?.some((inspection) => inspection.configured && providerCheckName(inspection.id, name));
-    })
-        .every(({ ok }) => ok);
-    return (coreHealthy &&
-        configuredProvidersHealthy &&
-        (providers.hopperAvailable ||
-            providers.providerInspections.some(({ available }) => available)));
-};
-const providerCheckName = (providerId, name) => name === providerId || name.startsWith(`${providerId}-`);
+const firstIlspyVersionLine = (value) => uniqueLines(value).find((line) => line.startsWith("ilspycmd:"));

package/dist/application/DoctorDiagnostics.js

@@ -0,0 +1,180 @@
+import { homedir } from "node:os";
+import { supportsNodeVersion } from "../domain/runtimeVersion.js";
+import { linuxHopperLauncherPath } from "./LinuxHopper.js";
+const DEFAULT_HOPPER = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
+const SYSTEM_LINUX_HOPPER = "/opt/hopper/bin/Hopper";
+/** Collect host, provider, and optional-target diagnostics without mutation. */
+export const collectDoctorDiagnostics = async (target, host) => {
+    const runtimeExecutables = await host.runtimeExecutables?.();
+    const checks = [
+        nodeCheck(host),
+        ...runtimeChecks(runtimeExecutables),
+    ];
+    checks.push(await hostCheck(host));
+    const hopperPath = await findHopper(host);
+    checks.push(hopperCheck(host, hopperPath));
+    const hopperVersionCheck = await optionalHopperVersionCheck(host, hopperPath);
+    if (hopperVersionCheck !== undefined)
+        checks.push(hopperVersionCheck);
+    const providerInspections = await host.providerInspections?.();
+    if (providerInspections !== undefined)
+        checks.push(...providerInspections.flatMap(providerDoctorChecks));
+    const javascriptReplayCheck = await host.javascriptReplayCheck?.();
+    if (javascriptReplayCheck !== undefined)
+        checks.push(javascriptReplayCheck);
+    const ilspyCheck = await optionalIlspyCheck(host);
+    if (ilspyCheck !== undefined)
+        checks.push(ilspyCheck);
+    const hopperDemoCheck = await optionalHopperDemoCheck(host, hopperPath);
+    if (hopperDemoCheck !== undefined)
+        checks.push(hopperDemoCheck);
+    const targetCheck = await optionalTargetCheck(target, host);
+    if (targetCheck !== undefined)
+        checks.push(targetCheck);
+    return {
+        checks,
+        ...(hopperPath === undefined ? {} : { hopperPath }),
+        ...(providerInspections === undefined ? {} : { providerInspections }),
+        ...(runtimeExecutables === undefined ? {} : { runtimeExecutables }),
+    };
+};
+/** Evaluate core health while treating unconfigured providers as optional. */
+export const doctorHealthy = (checks, providers) => {
+    if (providers.providerInspections === undefined)
+        return checks.every(({ ok }) => ok);
+    const providerChecks = checks.filter(({ name }) => name.startsWith("hopper") ||
+        providers.providerInspections?.some((inspection) => providerCheckName(inspection.id, name)) === true);
+    const coreHealthy = checks
+        .filter((candidate) => !providerChecks.includes(candidate))
+        .every(({ ok }) => ok);
+    const configuredProvidersHealthy = providerChecks
+        .filter(({ name }) => {
+        if (name.startsWith("hopper"))
+            return providers.hopperConfigured;
+        return providers.providerInspections?.some((inspection) => inspection.configured && providerCheckName(inspection.id, name));
+    })
+        .every(({ ok }) => ok);
+    return (coreHealthy &&
+        configuredProvidersHealthy &&
+        (providers.hopperAvailable ||
+            providers.providerInspections.some(({ available }) => available)));
+};
+const nodeCheck = (host) => check("node", supportsNodeVersion(host.nodeVersion), host.nodeVersion, {
+    remediation: "Install Node.js 22.19+ or 24.11+.",
+    classification: "missing_dependency",
+});
+const runtimeChecks = (inventory) => {
+    if (inventory === undefined)
+        return [];
+    const broken = inventory.candidates.filter(({ healthy }) => !healthy);
+    const detail = broken.length === 0
+        ? `${String(inventory.candidates.length)} runtime executable candidates passed bounded version probes.`
+        : `${String(broken.length)} of ${String(inventory.candidates.length)} runtime executable candidates failed bounded version probes: ${broken
+            .slice(0, 5)
+            .map(({ lexical_path: path }) => path)
+            .join(", ")}${broken.length > 5 ? ", …" : ""}`;
+    return [
+        check("node-toolchains", broken.length === 0, detail, {
+            remediation: "Select a verified healthy Node toolchain or repair the failing installation, then rerun rea doctor. Do not create compatibility-library symlinks.",
+            classification: "missing_dependency",
+        }),
+    ];
+};
+const hostCheck = async (host) => {
+    const macosVersion = host.platform === "darwin" ? await host.macosVersion() : undefined;
+    const linuxDistribution = host.platform === "linux" ? await host.linuxDistribution() : undefined;
+    const supported = (host.platform === "darwin" && parseMajor(macosVersion) >= 12) ||
+        (host.platform === "linux" && linuxDistribution?.supported === true) ||
+        (host.platform === "win32" && host.architecture === "x64");
+    const detail = macosVersion ??
+        (linuxDistribution === undefined
+            ? `${host.platform} ${host.architecture}`
+            : `${linuxDistribution.id} ${linuxDistribution.versionId ?? "unknown"}`);
+    return check("host", supported, detail, {
+        remediation: "REA supports macOS 12+, Ubuntu 24.04+, Fedora 41+, 64-bit Arch Linux, and the experimental Windows x64 Ghidra P0 boundary.",
+        classification: "unsupported_host",
+    });
+};
+const findHopper = async (host) => {
+    const candidates = host.configuredHopperPath === undefined
+        ? [
+            DEFAULT_HOPPER,
+            SYSTEM_LINUX_HOPPER,
+            linuxHopperLauncherPath(homedir()),
+            ...(await host.manualHopperPaths()),
+        ]
+        : [host.configuredHopperPath];
+    const hopperPath = await firstExecutable(host, candidates);
+    if (hopperPath !== undefined || host.configuredHopperPath !== undefined)
+        return hopperPath;
+    const brewCandidate = await host.brewHopperPath();
+    return firstExecutable(host, brewCandidate === undefined ? [] : [brewCandidate]);
+};
+const firstExecutable = async (host, candidates) => {
+    for (const candidate of new Set(candidates))
+        if (await host.executable(candidate))
+            return candidate;
+    return undefined;
+};
+const hopperCheck = (host, hopperPath) => check("hopper", hopperPath !== undefined, hopperPath ?? host.configuredHopperPath, {
+    remediation: host.configuredHopperPath === undefined
+        ? "Run rea setup to install Hopper, or set HOPPER_LAUNCHER_PATH."
+        : "Unset or update HOPPER_LAUNCHER_PATH to an executable Hopper launcher.",
+    classification: host.configuredHopperPath === undefined
+        ? "missing_analysis_engine"
+        : "config_drift",
+});
+const optionalHopperVersionCheck = async (host, hopperPath) => {
+    if (host.platform !== "linux" || hopperPath === undefined)
+        return undefined;
+    return check("hopper-version", await host.supportedLinuxHopper(hopperPath), hopperPath, {
+        remediation: unsupportedHopperRemediation(host.configuredHopperPath === hopperPath),
+        classification: "config_drift",
+    });
+};
+const optionalHopperDemoCheck = async (host, hopperPath) => host.platform !== "linux" || hopperPath === undefined
+    ? undefined
+    : check("hopper-demo-runtime", await host.linuxDemoRuntimeReady(), undefined, {
+        remediation: "Rerun rea setup to install the Xvfb, xauth, Python, X11, and XTEST packages required for Linux demo sessions.",
+        classification: "missing_dependency",
+    });
+const optionalIlspyCheck = async (host) => {
+    if (host.configuredIlspyCmdPath === undefined)
+        return undefined;
+    const version = await host.ilspyCmdVersion?.(host.configuredIlspyCmdPath);
+    return check("ilspycmd", version !== undefined, version === undefined
+        ? host.configuredIlspyCmdPath
+        : `${host.configuredIlspyCmdPath} (${version})`, {
+        remediation: "Unset REA_ILSPY_CMD_PATH or point it at a runnable ilspycmd executable.",
+        classification: "config_drift",
+    });
+};
+const optionalTargetCheck = async (target, host) => target === undefined
+    ? undefined
+    : check("target", await host.validTarget(target), target, {
+        remediation: "Supply a readable local app or program path.",
+        classification: "config_drift",
+    });
+const check = (name, ok, detail, failure) => ({
+    name,
+    ok,
+    classification: ok ? "healthy" : failure.classification,
+    ...(detail === undefined ? {} : { detail }),
+    ...(ok ? {} : { remediation: failure.remediation }),
+});
+const providerDoctorChecks = (inspection) => inspection.checks.map((candidate) => ({
+    name: candidate.name === "configuration"
+        ? inspection.id
+        : `${inspection.id}-${candidate.name}`,
+    ok: candidate.ok,
+    classification: candidate.ok ? "healthy" : candidate.classification,
+    detail: candidate.detail,
+    ...(candidate.remediation === null
+        ? {}
+        : { remediation: candidate.remediation }),
+}));
+const unsupportedHopperRemediation = (configured) => configured
+    ? "Unset or update HOPPER_LAUNCHER_PATH, install the Hopper build supported by this REA release, or update REA."
+    : "Install the Hopper build supported by this REA release, or update REA for a newer Hopper build.";
+const parseMajor = (version) => Number.parseInt(version?.split(".")[0] ?? "0", 10);
+const providerCheckName = (providerId, name) => name === providerId || name.startsWith(`${providerId}-`);