rea-agents 3.2.1 → 4.0.0

package/dist/application/ClientRegistrationStatus.js

@@ -4,19 +4,34 @@ import { resolve } from "node:path";
 import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { MCP_STARTUP_POLICY } from "../mcpStartupPolicy.js";
+import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { supportedClients } from "./SupportedClients.js";
 const registrationSchema = z
     .object({
     command: z.string().min(1),
     args: z.array(z.string()).default([]),
     startup_timeout_sec: z.number().positive().optional(),
+    type: z.string().optional(),
+    tools: z.array(z.string()).optional(),
+    disabled: z.boolean().optional(),
+    enabled: z.boolean().optional(),
 })
     .passthrough();
 /** Inspect supported client registrations without reading their environment. */
-export const readClientRegistrationStatuses = async (home, currentCommandPath = resolve(process.argv[1] ?? "unknown")) => {
+export const readClientRegistrationStatuses = async (home, currentCommandPath = resolve(process.argv[1] ?? "unknown"), options = {}) => {
     const statuses = [];
-    for (const client of supportedClients(home)) {
-        if (client.format === "unsupported" || !(await exists(client.markerPath)))
+    for (const client of supportedClients(home, options.platform, options.environment === undefined
+        ? undefined
+        : {
+            APPDATA: options.environment.APPDATA,
+            CLAUDE_CONFIG_DIR: options.environment.CLAUDE_CONFIG_DIR,
+            CODEX_HOME: options.environment.CODEX_HOME,
+            COPILOT_HOME: options.environment.COPILOT_HOME,
+            OPENCODE_CONFIG: options.environment.OPENCODE_CONFIG,
+            XDG_CONFIG_HOME: options.environment.XDG_CONFIG_HOME,
+        })) {
+        if (client.format === "unsupported" ||
+            (!(await exists(client.markerPath)) && !(await exists(client.configPath))))
             continue;
         try {
             const content = await readFile(client.configPath, "utf8");
@@ -26,12 +41,12 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
                 statuses.push(unavailableStatus(client.name, client.configPath, "missing"));
                 continue;
             }
-            const registration = registrationSchema.parse(raw);
+            const registration = parseRegistration(raw, client);
             const command = [
                 registration.command,
                 ...registration.args,
             ];
-            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client.name, currentCommandPath)
+            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client, currentCommandPath)
                 ? "aligned"
                 : "stale"));
         }
@@ -43,10 +58,25 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
 };
 const registrationAligned = (registration, client, currentCommandPath) => {
     const command = [registration.command, ...registration.args];
-    if (client === "codex" &&
+    if (registration.disabled === true || registration.enabled === false)
+        return false;
+    if (!isOwnedClientRegistrationCommand(command, currentCommandPath))
+        return false;
+    if (command.length === 3 &&
+        command[2] === "mcp" &&
+        resolve(command[0] ?? "") === resolve(process.execPath) &&
+        resolve(command[1] ?? "") === currentCommandPath)
+        return true;
+    if (client.name === "codex" &&
         registration.startup_timeout_sec !==
             MCP_STARTUP_POLICY.codexStartupTimeoutSeconds)
         return false;
+    if (client.format === "vscode" && registration.type !== "stdio")
+        return false;
+    if (client.format === "copilot_cli" &&
+        (registration.type !== "stdio" ||
+            JSON.stringify(registration.tools) !== JSON.stringify(["*"])))
+        return false;
     if (command.length === 4 &&
         command[0] === "npx" &&
         command[1] === "-y" &&
@@ -57,6 +87,29 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         command[1] === "mcp" &&
         resolve(command[0] ?? "") === currentCommandPath);
 };
+const parseRegistration = (value, client) => {
+    if (client.format === "opencode") {
+        const entry = z
+            .object({
+            type: z.literal("local"),
+            command: z.array(z.string()).min(1),
+            environment: z.record(z.string(), z.string()).optional(),
+        })
+            .passthrough()
+            .parse(value);
+        const [command = "", ...args] = entry.command;
+        return registrationSchema.parse({
+            ...entry,
+            command,
+            args,
+        });
+    }
+    const registration = registrationSchema.parse(value);
+    if ((client.format === "vscode" || client.format === "copilot_cli") &&
+        registration.type !== "stdio")
+        throw new TypeError("Expected an stdio registration");
+    return registration;
+};
 const remediation = "Run rea setup to refresh this registration, then restart the client.";
 const configuredStatus = (client, configPath, command, state) => state === "aligned"
     ? { client, config_path: configPath, command, state, remediation: null }

package/dist/application/DirectAnalysis.js

@@ -1,17 +1,15 @@
-import { projectPermissionFailure } from "./PermissionFailure.js";
-import { artifactExtractionPermissionRequest } from "./ArtifactExtractionDestination.js";
 import { parseConfig } from "../config.js";
 import { EnhancedTools } from "./EnhancedTools.js";
-import { createBinarySession } from "./runtime.js";
+import { createBinarySession, createManagedBinarySession } from "./runtime.js";
 import { silentLogger } from "../logger.js";
 import { createEvidence } from "../domain/evidence.js";
+import { isManagedToolName, } from "../contracts/managedToolContracts.js";
 import { EvidenceIntegrityError, projectAnalysisError, } from "../domain/errors.js";
 import { access } from "node:fs/promises";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "./AnalysisSnapshotFiles.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { snapshotEvidenceForQuery, snapshotMatchesTarget, } from "../domain/analysisSnapshot.js";
 import { err, ok } from "../domain/result.js";
-import { loadConfiguredPermissionAuthority } from "./PermissionConfiguration.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
 export { runCapabilityStatus, runProviderStatus, } from "./DirectAnalysisStatus.js";
@@ -27,69 +25,47 @@ export const runDirectAnalysis = async (path, tool, arguments_, options = {}) =>
     ...(options.providerId === undefined
         ? {}
         : { providerId: options.providerId }),
-    ...(options.permissionAuthority === undefined
-        ? {}
-        : { permissionAuthority: options.permissionAuthority }),
 }));
 /** Execute one provider-native semantic operation with atomic provenance. */
-export const runProviderAnalysis = async (...[path, tool, arguments_, logger = silentLogger, signal]) => withProcessCancellation(signal, (operationSignal) => runAnalysis(path, tool, arguments_, {
-    logger,
-    snapshotPath: undefined,
-    signal: operationSignal,
-}));
-const authorizeAnalysis = async (authority, tool, arguments_) => {
-    const requests = [];
-    if (tool === "extract_artifact" && typeof arguments_.output_root === "string")
-        requests.push({
-            request: artifactExtractionPermissionRequest(),
-            access: "write",
-        });
-    for (const request of requests) {
-        const result = await authority.authorize(request.request, request.access);
-        if (!result.ok)
-            return err(projectPermissionFailure(result.error));
+export const runProviderAnalysis = async (...[path, tool, arguments_, logger = silentLogger, signal]) => isManagedToolName(tool)
+    ? runManagedProviderAnalysis(path, tool, signal)
+    : withProcessCancellation(signal, (operationSignal) => runAnalysis(path, tool, arguments_, {
+        logger,
+        snapshotPath: undefined,
+        signal: operationSignal,
+    }));
+/** Execute managed metadata inspection in an isolated managed-only session. */
+export const runManagedProviderExecution = async (path, tool, signal) => withProcessCancellation(signal, async (operationSignal) => {
+    const session = createManagedBinarySession();
+    try {
+        const opened = await session.open(path, { signal: operationSignal });
+        if (!opened.ok)
+            return opened;
+        return await session.execute(tool, {}, { signal: operationSignal });
     }
-    if (["inventory_artifact", "inspect_artifact"].includes(tool) &&
-        arguments_.native_mount_approved === true) {
-        const result = await authority.authorize({
-            capability: "native_mount",
-            roots: [],
-            executables: [],
-            environment_names: [],
-            network: "none",
-            mount: true,
-            operation_identity: `${tool}:native_mount`,
-        }, "read");
-        if (!result.ok)
-            return err(projectPermissionFailure(result.error));
+    finally {
+        await session.close();
     }
-    return ok(null);
-};
-const permissionAuthorityFor = (config, supplied) => supplied === undefined
-    ? loadConfiguredPermissionAuthority(config)
-    : Promise.resolve(ok(supplied));
-const authorizeAnalysisRun = async (input) => {
-    const authority = await permissionAuthorityFor(input.config, input.suppliedAuthority);
-    if (!authority.ok)
-        return authority;
-    const operation = await authorizeAnalysis(authority.value, input.tool, input.arguments);
-    if (!operation.ok)
-        return operation;
-    return ok(null);
+});
+const runManagedProviderAnalysis = async (path, tool, signal) => {
+    const execution = await runManagedProviderExecution(path, tool, signal);
+    if (!execution.ok)
+        return cliError(execution.error);
+    const value = execution.value;
+    return createEvidence(value.subject ?? undefined, value.provider, {
+        operation: tool,
+        parameters: {},
+        result: value.result,
+        rawResult: value.rawResult,
+        limitations: value.limitations,
+        locations: value.locations,
+    });
 };
 const runAnalysis = async (path, tool, arguments_, options) => {
     const { logger, signal, snapshotPath } = options;
-    const config = parseConfig(process.env);
+    const config = parseConfig(options.environment ?? process.env);
     if (!config.ok)
         return cliError(config.error);
-    const authorization = await authorizeAnalysisRun({
-        config: config.value,
-        suppliedAuthority: options.permissionAuthority,
-        tool,
-        arguments: arguments_,
-    });
-    if (!authorization.ok)
-        return cliError(authorization.error);
     const session = createBinarySession(config.value, logger);
     try {
         const prepared = await prepareSnapshot({
@@ -158,6 +134,7 @@ const executeAnalysisTool = async (input) => {
         tool === "inspect_native_api" ||
         tool === "inspect_native_dispatch_metadata" ||
         tool === "trace_feature" ||
+        tool === "trace_native_values" ||
         tool === "trace_native_ui_action") {
         const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
         if (!result.ok)
@@ -234,7 +211,9 @@ const analysisProfileForEvidence = (session, tool) => {
 };
 const isWorkflowEvidenceTool = (tool) => tool === "binary_overview" ||
     tool === "inspect_native_api" ||
+    tool === "inspect_native_dispatch_metadata" ||
     tool === "trace_feature" ||
+    tool === "trace_native_values" ||
     tool === "trace_native_ui_action";
 const fileExists = async (path) => {
     try {

package/dist/application/DirectAnalysisStatus.js

@@ -4,8 +4,8 @@ import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { silentLogger } from "../logger.js";
 import { createBinarySession } from "./runtime.js";
-const runSessionStatus = async (logger = silentLogger) => {
-    const config = parseConfig(process.env);
+const runSessionStatus = async (logger = silentLogger, environment = process.env) => {
+    const config = parseConfig(environment);
     if (!config.ok)
         return { error: projectAnalysisError(config.error) };
     const session = createBinarySession(config.value, logger);
@@ -22,6 +22,6 @@ const runSessionStatus = async (logger = silentLogger) => {
     }
 };
 /** List complete provider identities, capabilities, and availability. */
-export const runProviderStatus = (logger = silentLogger) => runSessionStatus(logger);
+export const runProviderStatus = (logger = silentLogger, environment = process.env) => runSessionStatus(logger, environment);
 /** List complete operation descriptors and availability. */
-export const runCapabilityStatus = (logger = silentLogger) => runSessionStatus(logger);
+export const runCapabilityStatus = (logger = silentLogger, environment = process.env) => runSessionStatus(logger, environment);

package/dist/application/Doctor.js

@@ -9,7 +9,6 @@ import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDis
 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";
 import { normalizeDoctorScope, scopeDoctorChecks, } from "./DoctorScope.js";
 /** Deep provider IDs whose readiness can be selected explicitly by doctor. */
@@ -20,8 +19,8 @@ export const DOCTOR_PROVIDER_IDS = ["hopper", "ghidra"];
  * or an agent consuming the structured result.
  */
 export const runDoctor = async (target, host = systemDoctorHost(), requestedScope) => {
-    const { checks: diagnosticChecks, hopperPath, providerInspections, runtimeExecutables, } = await collectDoctorDiagnostics(target, host);
-    const identity = await collectDoctorIdentity(host, runtimeExecutables);
+    const { checks: diagnosticChecks, hopperPath, providerInspections, } = await collectDoctorDiagnostics(target, host);
+    const identity = await collectDoctorIdentity(host);
     const checks = [...diagnosticChecks, ...identity.checks];
     const providers = {
         hopperAvailable: hopperPath !== undefined &&
@@ -52,7 +51,7 @@ export const runDoctor = async (target, host = systemDoctorHost(), requestedScop
         identity: identity.value,
     };
 };
-const collectDoctorIdentity = async (host, runtimeExecutables) => {
+const collectDoctorIdentity = async (host) => {
     const installationPaths = (await host.installationPaths?.()) ?? [];
     const installedSkillIdentity = await host.installedSkillIdentity?.();
     const skillAligned = skillIdentityAligned(installedSkillIdentity);
@@ -91,7 +90,6 @@ const collectDoctorIdentity = async (host, runtimeExecutables) => {
                     : "Run rea setup to update the installed REA skill.",
             },
             registrations,
-            runtime_executables: runtimeExecutables ?? null,
         },
     };
 };
@@ -115,91 +113,102 @@ const registrationCheck = (registration) => ({
     remediation: registration.remediation,
 });
 const installationState = (paths) => paths.length === 0 ? "unknown" : paths.length === 1 ? "single" : "multiple";
+const homeFromEnvironment = (environment, platform) => {
+    const selected = platform === "win32"
+        ? (environment.USERPROFILE ??
+            (environment.HOMEDRIVE !== undefined &&
+                environment.HOMEPATH !== undefined
+                ? `${environment.HOMEDRIVE}${environment.HOMEPATH}`
+                : environment.HOME))
+        : (environment.HOME ?? environment.USERPROFILE);
+    return selected ?? homedir();
+};
 /** 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 }),
-    ...(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;
-    },
-    executable: executableAvailable,
-    linuxDemoRuntimeCheck: options.linuxDemoRuntimeCheck ?? uncomposedLinuxDemoRuntimeCheck,
-    supportedLinuxHopper: linuxHopperBinarySupported,
-    async brewHopperPath() {
-        return probeHomebrew(async (command) => {
+export const systemDoctorHost = (options = {}) => {
+    const platform = options.platform ?? process.platform;
+    const architecture = options.architecture ?? process.arch;
+    const environment = options.environment ?? process.env;
+    const hostExecFileOutput = options.execFileOutput ?? execFileOutput;
+    const homeDirectory = homeFromEnvironment(environment, platform);
+    const commandEnvironment = { env: environment };
+    return {
+        platform,
+        architecture,
+        nodeVersion: process.versions.node,
+        homeDirectory,
+        ...(environment.HOPPER_LAUNCHER_PATH === undefined
+            ? {}
+            : { configuredHopperPath: environment.HOPPER_LAUNCHER_PATH }),
+        ...(environment.REA_ILSPY_CMD_PATH === undefined
+            ? {}
+            : { configuredIlspyCmdPath: environment.REA_ILSPY_CMD_PATH }),
+        macosVersion: () => readMacosVersion(hostExecFileOutput, commandEnvironment),
+        linuxDistribution: readLinuxDistribution,
+        async validTarget(path) {
+            return (await parseBinaryTarget(path, process.cwd(), architecture)).ok;
+        },
+        executable: (path) => executableAvailable(path, platform, hostExecFileOutput, commandEnvironment),
+        linuxDemoRuntimeCheck: options.linuxDemoRuntimeCheck ?? uncomposedLinuxDemoRuntimeCheck,
+        supportedLinuxHopper: linuxHopperBinarySupported,
+        async brewHopperPath() {
+            return probeHomebrew(async (command) => {
+                try {
+                    const prefix = (await hostExecFileOutput(command, ["--prefix", "--cask", "hopper-disassembler"], commandEnvironment)).stdout.trim();
+                    return `${prefix}/Hopper Disassembler.app/Contents/MacOS/hopper`;
+                }
+                catch {
+                    return undefined;
+                }
+            });
+        },
+        manualHopperPaths: () => manualHopperPaths(homeDirectory),
+        ...(options.providerInspections === undefined
+            ? {}
+            : { providerInspections: options.providerInspections }),
+        async ilspyCmdVersion(path) {
             try {
-                const prefix = (await execFileOutput(command, [
-                    "--prefix",
-                    "--cask",
-                    "hopper-disassembler",
-                ])).stdout.trim();
-                return `${prefix}/Hopper Disassembler.app/Contents/MacOS/hopper`;
+                await access(path, constants.X_OK);
+                return firstIlspyVersionLine((await hostExecFileOutput(path, ["--version"], {
+                    timeout: 10_000,
+                    ...commandEnvironment,
+                })).stdout);
             }
             catch {
                 return undefined;
             }
-        });
-    },
-    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 execFileOutput(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";
-            const arguments_ = process.platform === "win32" ? ["rea"] : ["-a", "rea"];
-            return uniqueLines((await execFileOutput(command, arguments_)).stdout);
-        }
-        catch {
-            return [];
-        }
-    },
-    installedSkillIdentity,
-    clientRegistrations: () => readClientRegistrationStatuses(homedir()),
-});
-const readMacosVersion = async () => {
+        },
+        async installationPaths() {
+            try {
+                const command = platform === "win32" ? "where" : "which";
+                const arguments_ = platform === "win32" ? ["rea"] : ["-a", "rea"];
+                return uniqueLines((await hostExecFileOutput(command, arguments_, commandEnvironment))
+                    .stdout);
+            }
+            catch {
+                return [];
+            }
+        },
+        installedSkillIdentity: () => installedSkillIdentity(homeDirectory),
+        clientRegistrations: () => readClientRegistrationStatuses(homeDirectory, undefined, {
+            platform,
+            environment,
+        }),
+    };
+};
+const readMacosVersion = async (run = execFileOutput, options = { env: process.env }) => {
     try {
-        return (await execFileOutput("sw_vers", ["-productVersion"])).stdout.trim();
+        return (await run("sw_vers", ["-productVersion"], options)).stdout.trim();
     }
     catch {
         return undefined;
     }
 };
-const executableAvailable = async (path) => {
+const executableAvailable = async (path, platform = process.platform, run = execFileOutput, options = { env: process.env }) => {
     try {
         await access(path, constants.X_OK);
-        if (process.platform !== "linux")
+        if (platform !== "linux")
             return true;
-        const linked = await execFileOutput("ldd", [path]);
+        const linked = await run("ldd", [path], options);
         return linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`);
     }
     catch {
@@ -213,9 +222,9 @@ const uncomposedLinuxDemoRuntimeCheck = () => Promise.resolve({
     detail: "Linux Hopper private-display diagnostics were not composed",
     remediation: "Run rea doctor through the production CLI adapter.",
 });
-const manualHopperPaths = async () => {
+const manualHopperPaths = async (home = homedir()) => {
     const paths = [];
-    for (const root of ["/Applications", join(homedir(), "Applications")]) {
+    for (const root of ["/Applications", join(home, "Applications")]) {
         try {
             for (const entry of await readdir(root, { withFileTypes: true })) {
                 if (entry.isDirectory() && /^Hopper.*\.app$/i.test(entry.name))
@@ -228,10 +237,10 @@ const manualHopperPaths = async () => {
     }
     return paths;
 };
-const readInstalledSkill = () => readFile(join(homedir(), ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"), "utf8");
-const installedSkillIdentity = async () => {
+const readInstalledSkill = (home) => readFile(join(home, ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"), "utf8");
+const installedSkillIdentity = async (home) => {
     try {
-        const content = await readInstalledSkill();
+        const content = await readInstalledSkill(home);
         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,

package/dist/application/DoctorDiagnostics.js

@@ -5,11 +5,7 @@ const DEFAULT_HOPPER = "/Applications/Hopper Disassembler.app/Contents/MacOS/hop
 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),
-    ];
+    const checks = [nodeCheck(host)];
     checks.push(await hostCheck(host));
     const hopperPath = await findHopper(host);
     checks.push(hopperCheck(host, hopperPath));
@@ -19,9 +15,6 @@ export const collectDoctorDiagnostics = async (target, host) => {
     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);
@@ -35,7 +28,6 @@ export const collectDoctorDiagnostics = async (target, host) => {
         checks,
         ...(hopperPath === undefined ? {} : { hopperPath }),
         ...(providerInspections === undefined ? {} : { providerInspections }),
-        ...(runtimeExecutables === undefined ? {} : { runtimeExecutables }),
     };
 };
 /** Evaluate core health while treating unconfigured providers as optional. */
@@ -63,22 +55,6 @@ const nodeCheck = (host) => check("node", supportsNodeVersion(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
-            .map(({ lexical_path: path }) => path)
-            .join(", ")}`;
-    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;
@@ -99,7 +75,7 @@ const findHopper = async (host) => {
         ? [
             DEFAULT_HOPPER,
             SYSTEM_LINUX_HOPPER,
-            linuxHopperLauncherPath(homedir()),
+            linuxHopperLauncherPath(host.homeDirectory ?? homedir()),
             ...(await host.manualHopperPaths()),
         ]
         : [host.configuredHopperPath];

package/dist/application/DoctorScope.js

@@ -1,4 +1,3 @@
-import { doctorHealthy } from "./DoctorDiagnostics.js";
 /** Normalize a caller-selected doctor readiness boundary. */
 export const normalizeDoctorScope = (requested, target) => ({
     mode: requested === undefined ? "audit-wide" : "explicit",
@@ -10,40 +9,35 @@ export const normalizeDoctorScope = (requested, target) => ({
 /** Partition diagnostics into required and informational scope checks. */
 export const scopeDoctorChecks = (input) => {
     const providerChecks = input.checks.filter((candidate) => isProviderCheck(candidate.name, input.providers.providerInspections));
-    const coreChecks = input.checks.filter(({ name }) => !isProviderCheck(name, input.providers.providerInspections) &&
-        name !== "skill:identity" &&
-        !name.startsWith("registration:"));
+    const coreChecks = input.checks.filter(({ name }) => name === "node" || (input.scope.target !== null && name === "target"));
     const clientChecks = input.scope.clients.map((client) => selectedRegistrationCheck(client, input.registrations.find((candidate) => candidate.client === client)));
     const skillChecks = input.scope.skill
         ? [selectedSkillCheck(input.skillState, input.checks)]
         : [];
-    const selectedProviderChecks = input.scope.providers.length === 0
-        ? configuredProviderChecks(providerChecks, input.providers)
-        : input.scope.providers.flatMap((providerId) => selectedProviderChecksFor(providerId, providerChecks, input.providers));
+    const selectedProviderChecks = input.scope.providers.flatMap((providerId) => selectedProviderChecksFor(providerId, providerChecks, input.providers));
+    const hopperHostChecks = input.scope.providers.includes("hopper")
+        ? input.checks.filter(({ name }) => name === "host")
+        : [];
     const scopeChecks = [
         ...coreChecks,
+        ...hopperHostChecks,
         ...selectedProviderChecks,
         ...clientChecks,
         ...skillChecks,
     ];
-    const providerHealthy = input.scope.providers.length === 0
-        ? doctorHealthy([...coreChecks, ...providerChecks, ...clientChecks, ...skillChecks], input.providers)
-        : selectedProviderChecks.every(({ ok }) => ok);
     const selectedNames = new Set(scopeChecks.map(({ name }) => name));
     return {
         healthy: coreChecks.every(({ ok }) => ok) &&
+            hopperHostChecks.every(({ ok }) => ok) &&
             clientChecks.every(({ ok }) => ok) &&
             skillChecks.every(({ ok }) => ok) &&
-            providerHealthy,
+            selectedProviderChecks.every(({ ok }) => ok),
         scopeChecks,
         informationalChecks: input.checks.filter(({ name }) => !selectedNames.has(name)),
     };
 };
 const isProviderCheck = (name, inspections) => name.startsWith("hopper") ||
     inspections?.some(({ id }) => doctorProviderCheckName(id, name)) === true;
-const configuredProviderChecks = (checks, providers) => checks.filter(({ name }) => name.startsWith("hopper")
-    ? providers.hopperConfigured
-    : providers.providerInspections?.some(({ id, configured }) => configured && doctorProviderCheckName(id, name)) === true);
 const selectedProviderChecksFor = (providerId, checks, providers) => {
     const selected = checks.filter(({ name }) => providerId === "hopper"
         ? name.startsWith("hopper")