rea-agents 6.0.0 → 6.2.0

package/dist/application/ClientRegistrationIdentity.js

@@ -1,6 +1,26 @@
 import { basename, isAbsolute, resolve } from "node:path";
 import { valid } from "semver";
 import { PRODUCT_IDENTITY } from "../identity.js";
+/** Resolve a pinned npx launcher that stdio clients can spawn on the host. */
+export const npxRegistrationCommand = (platform = process.platform) => {
+    const command = [
+        "npx",
+        "-y",
+        PRODUCT_IDENTITY.registrationPackageSpecifier,
+        "mcp",
+    ];
+    return platform === "win32" ? ["cmd.exe", "/d", "/c", ...command] : command;
+};
+const unwrapNpxCommand = (command) => {
+    const executable = command[0]?.toLowerCase();
+    if (executable !== "cmd" && executable !== "cmd.exe")
+        return command;
+    if (command[1]?.toLowerCase() === "/c")
+        return command.slice(2);
+    if (command[1]?.toLowerCase() === "/d" && command[2]?.toLowerCase() === "/c")
+        return command.slice(3);
+    return [];
+};
 /** Check that one parsed command points to REA's MCP entry point. */
 export const isOwnedClientRegistrationCommand = (command, currentCommandPath = resolve(process.argv[1] ?? "unknown")) => {
     if (command.length === 3 &&
@@ -16,12 +36,13 @@ export const isOwnedClientRegistrationCommand = (command, currentCommandPath = r
             resolve(executable) === currentCommandPath)
             return true;
     }
-    if (command.length !== 4 ||
-        command[0] !== "npx" ||
-        command[1] !== "-y" ||
-        command[3] !== "mcp")
+    const npxCommand = unwrapNpxCommand(command);
+    if (npxCommand.length !== 4 ||
+        npxCommand[0] !== "npx" ||
+        npxCommand[1] !== "-y" ||
+        npxCommand[3] !== "mcp")
         return false;
-    const packageReference = command[2] ?? "";
+    const packageReference = npxCommand[2] ?? "";
     if (packageReference === PRODUCT_IDENTITY.packageName ||
         packageReference === PRODUCT_IDENTITY.packageSpecifier ||
         packageReference === PRODUCT_IDENTITY.registrationPackageSpecifier)

package/dist/application/ClientRegistrationStatus.js

@@ -1,11 +1,11 @@
-import { effectiveClientServer, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
+import { effectiveClientServer, grokServerListedDisabled, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { access, readFile } from "node:fs/promises";
 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";
+import { isOwnedClientRegistrationCommand, npxRegistrationCommand, } from "./ClientRegistrationIdentity.js";
+import { manualRegistrationRemediation, supportedClients, } from "./SupportedClients.js";
 const registrationSchema = z
     .object({
     command: z.string().min(1),
@@ -28,15 +28,30 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
             CLAUDE_CONFIG_DIR: options.environment.CLAUDE_CONFIG_DIR,
             CODEX_HOME: options.environment.CODEX_HOME,
             COPILOT_HOME: options.environment.COPILOT_HOME,
+            GROK_HOME: options.environment.GROK_HOME,
             OPENCODE_CONFIG: options.environment.OPENCODE_CONFIG,
+            SAND_DATA_ROOT: options.environment.SAND_DATA_ROOT,
             XDG_CONFIG_HOME: options.environment.XDG_CONFIG_HOME,
         })) {
-        if (client.format === "unsupported" ||
-            (!(await exists(client.markerPath)) && !(await exists(client.configPath))))
+        if (!(await exists(client.markerPath)) &&
+            !(await exists(client.configPath)))
             continue;
+        const manualRemediation = manualRegistrationRemediation(client.name);
+        if (client.format === "unsupported") {
+            if (manualRemediation !== undefined)
+                statuses.push({
+                    client: client.name,
+                    config_path: client.markerPath ?? client.configPath,
+                    command: [],
+                    state: "manual",
+                    remediation: manualRemediation,
+                });
+            continue;
+        }
         try {
             const content = await readFile(client.configPath, "utf8");
-            const raw = effectiveClientServer(parseClientConfiguration(content, client.format), PRODUCT_IDENTITY.mcpServerKey);
+            const parsed = parseClientConfiguration(content, client.format);
+            const raw = effectiveClientServer(parsed, PRODUCT_IDENTITY.mcpServerKey);
             if (raw === undefined) {
                 statuses.push(unavailableStatus(client.name, client.configPath, "missing"));
                 continue;
@@ -46,7 +61,9 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
                 registration.command,
                 ...registration.args,
             ];
-            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client, currentCommandPath)
+            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client, currentCommandPath, options.platform ?? process.platform) &&
+                !(client.format === "grok" &&
+                    grokServerListedDisabled(parsed.document, PRODUCT_IDENTITY.mcpServerKey))
                 ? "aligned"
                 : "stale"));
         }
@@ -56,13 +73,13 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
     }
     return statuses.sort((left, right) => left.client.localeCompare(right.client));
 };
-const registrationAligned = (registration, client, currentCommandPath) => {
+const registrationAligned = (registration, client, currentCommandPath, platform) => {
     const command = [registration.command, ...registration.args];
     if (registration.disabled === true || registration.enabled === false)
         return false;
     if (!isOwnedClientRegistrationCommand(command, currentCommandPath))
         return false;
-    if (client.name === "codex" &&
+    if ((client.name === "codex" || client.name === "grok_build") &&
         registration.startup_timeout_sec !==
             MCP_STARTUP_POLICY.codexStartupTimeoutSeconds)
         return false;
@@ -79,11 +96,9 @@ const registrationAligned = (registration, client, currentCommandPath) => {
         resolve(command[0] ?? "") === resolve(process.execPath) &&
         resolve(command[1] ?? "") === currentCommandPath)
         return true;
-    if (command.length === 4 &&
-        command[0] === "npx" &&
-        command[1] === "-y" &&
-        command[2] === PRODUCT_IDENTITY.registrationPackageSpecifier &&
-        command[3] === "mcp")
+    const npxCommand = npxRegistrationCommand(platform);
+    if (command.length === npxCommand.length &&
+        command.every((argument, index) => argument === npxCommand[index]))
         return true;
     return (command.length === 2 &&
         command[1] === "mcp" &&

package/dist/application/DirectAnalysis.js

@@ -1,4 +1,3 @@
-import { parseConfig } from "../config.js";
 import { EnhancedTools } from "./EnhancedTools.js";
 import { executeFunctionAnalysisEvidence } from "./FunctionAnalysisEvidence.js";
 import { silentLogger } from "../logger.js";
@@ -11,10 +10,13 @@ import { access } from "node:fs/promises";
 import { readAnalysisSnapshot, writeAnalysisSnapshot, } from "./binary/AnalysisSnapshotFiles.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { snapshotEvidenceForQuery, snapshotMatchesTarget, } from "../domain/analysisSnapshot.js";
-import { analysisProfileSchema, committedProviderSchema, } from "../domain/analysisProfile.js";
 import { err, ok } from "../domain/result.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
+import { createWorkflowEvidence, workflowSnapshotRecord, recordWorkflowUnknowns, } from "./WorkflowEvidence.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
+import { resolveXrefsAddress } from "./XrefsAddressResolution.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { directAnalysisCleanupFailure, managedAnalysisCleanupFailure, withSessionCleanup, } from "./DirectAnalysisCleanup.js";
 /**
  * Open one binary, execute one tool, and always release provider resources.
  * Unlike MCP mode, every CLI invocation is intentionally isolated and does not
@@ -42,15 +44,12 @@ export const runProviderAnalysis = async (dependencies, ...[path, tool, argument
 /** Execute managed metadata inspection in an isolated managed-only session. */
 export const runManagedProviderExecution = async (dependencies, path, tool, signal) => withProcessCancellation(signal, async (operationSignal) => {
     const session = dependencies.createManagedBinarySession();
-    try {
+    return withSessionCleanup(session, async () => {
         const opened = await session.open(path, { signal: operationSignal });
         if (!opened.ok)
             return opened;
         return await session.execute(tool, {}, { signal: operationSignal });
-    }
-    finally {
-        await session.close();
-    }
+    }, managedAnalysisCleanupFailure);
 });
 const runManagedProviderAnalysis = async (dependencies, path, tool, signal) => {
     const execution = await runManagedProviderExecution(dependencies, path, tool, signal);
@@ -68,11 +67,11 @@ const runManagedProviderAnalysis = async (dependencies, path, tool, signal) => {
 };
 const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
     const { logger, signal, snapshotPath } = options;
-    const config = parseConfig(options.environment ?? process.env);
+    const config = dependencies.readConfiguration();
     if (!config.ok)
         return cliError(config.error);
     const session = dependencies.createBinarySession(config.value, logger);
-    try {
+    return withSessionCleanup(session, async () => {
         const prepared = await prepareSnapshot({
             path,
             snapshotPath,
@@ -142,38 +141,32 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
             signal,
             evidenceProfile,
         });
-        if (evidence !== undefined)
-            session.recordEvidence(evidence);
+        if (evidence !== undefined) {
+            const recorded = session.recordEvidence(evidence);
+            if (!recorded.ok)
+                return cliError(recorded.error);
+            if (isWorkflowEvidenceTool(tool)) {
+                const unknowns = recordWorkflowUnknowns({
+                    name: tool,
+                    result: evidence.normalized_result,
+                    evidenceId: evidence.evidence_id,
+                    recordUnknown: (unknown) => session.recordUnknown(unknown),
+                });
+                if (!unknowns.ok)
+                    return cliError(unknowns.error);
+            }
+        }
         if (isWorkflowEvidenceTool(tool) &&
             tool !== "trace_native_ui_action" &&
             snapshotPath !== undefined &&
             evidence !== undefined &&
-            "analysis_profile" in evidence &&
             session.allowsSnapshotReplay(tool)) {
-            const recorded = session.recordWorkflowSnapshot({
-                operation: tool,
-                parameters: arguments_,
-                execution: {
-                    result: evidence.normalized_result,
-                    rawResult: evidence.raw_result,
-                    provider: committedProviderSchema.parse(evidence.provider),
-                    analysisProfile: analysisProfileSchema.parse(evidence.analysis_profile),
-                    limitations: evidence.limitations,
-                    locations: evidence.locations,
-                    subject: evidence.subject === null
-                        ? null
-                        : {
-                            path: evidence.subject.local_path,
-                            sha256: evidence.subject.digest.sha256,
-                            format: evidence.subject.format,
-                            ...(evidence.subject.architecture === null
-                                ? {}
-                                : { architecture: evidence.subject.architecture }),
-                        },
-                },
-            });
-            if (!recorded.ok)
-                return cliError(recorded.error);
+            const workflowRecord = workflowSnapshotRecord(evidence, tool);
+            if (workflowRecord !== undefined) {
+                const recorded = session.recordWorkflowSnapshot(workflowRecord);
+                if (!recorded.ok)
+                    return cliError(recorded.error);
+            }
         }
         if (tool !== "trace_native_ui_action" &&
             snapshotPath !== undefined &&
@@ -186,10 +179,7 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
                 return cliError(written.error);
         }
         return output;
-    }
-    finally {
-        await session.close();
-    }
+    }, directAnalysisCleanupFailure);
 };
 const executeAnalysisTool = async (input) => {
     const { session, tool, signal, evidenceProfile } = input;
@@ -208,19 +198,31 @@ const executeAnalysisTool = async (input) => {
         const result = await new EnhancedTools(session).execute(tool, input.arguments, signal);
         if (!result.ok)
             return { output: cliError(result.error) };
-        const evidence = createEvidence(input.openedTarget, REA_WORKFLOW_PROVIDER, {
+        const evidence = createWorkflowEvidence({
+            target: input.openedTarget,
             operation: tool,
             parameters: input.arguments,
             result: result.value,
-            ...(evidenceProfile === undefined
-                ? {}
-                : { analysisProfile: evidenceProfile }),
-            confidence: "derived",
-            limitations: ["Derived by an REA composed workflow."],
+            upstreamProfile: evidenceProfile,
         });
         return { output: evidence, evidence };
     }
-    const result = await session.execute(tool, input.arguments, { signal });
+    let result = await session.execute(tool, input.arguments, { signal });
+    if (tool === "xrefs" &&
+        typeof input.arguments.address === "string" &&
+        !result.ok &&
+        result.error instanceof AnalysisInputError &&
+        !result.error.cleanupIncomplete &&
+        result.error.issues.length > 0 &&
+        result.error.issues.every(({ path, reason }) => path.length === 1 &&
+            path[0] === "address" &&
+            reason === "invalid_format")) {
+        const address = await resolveXrefsAddress(session, input.arguments.address, signal);
+        if (!address.ok)
+            return { output: cliError(address.error) };
+        if (address.value !== input.arguments.address)
+            result = await session.execute(tool, { ...input.arguments, address: address.value }, { signal });
+    }
     if (!result.ok)
         return { output: cliError(result.error) };
     const evidence = createEvidence(result.value.subject ?? input.openedTarget, result.value.provider, {
@@ -245,12 +247,16 @@ const withProcessCancellation = async (suppliedSignal, operation) => {
         return operation(suppliedSignal);
     const controller = new AbortController();
     const cancel = () => controller.abort();
-    process.once("SIGINT", cancel);
+    // Package runners can forward a terminal interrupt after REA already received
+    // it directly. Keep both guards installed until provider cleanup has settled.
+    process.on("SIGINT", cancel);
+    process.on("SIGTERM", cancel);
     try {
         return await operation(controller.signal);
     }
     finally {
         process.off("SIGINT", cancel);
+        process.off("SIGTERM", cancel);
     }
 };
 const prepareSnapshot = async (options) => {
@@ -280,7 +286,7 @@ const analysisProfileForRoute = (route, tool) => {
     if (profile === null || profile === undefined)
         return undefined;
     if (isWorkflowEvidenceTool(tool))
-        return workflowAnalysisProfile(profile);
+        return workflowAnalysisProfile(profile, tool);
     const provider = providerIdentityForRoute(route, tool);
     return provider.id === profile.provider.id ? profile : undefined;
 };
@@ -294,8 +300,7 @@ const providerIdentityForRoute = (route, operation) => {
 const analysisProfileForEvidence = (session, tool) => {
     if (!isWorkflowEvidenceTool(tool))
         return session.analysisProfile(tool);
-    const upstream = session.analysisProfile();
-    return upstream === undefined ? undefined : workflowAnalysisProfile(upstream);
+    return session.analysisProfile();
 };
 const isWorkflowEvidenceTool = (tool) => tool === "binary_overview" ||
     tool === "inspect_native_api" ||

package/dist/application/DirectAnalysisCleanup.js

@@ -0,0 +1,72 @@
+import { analysisErrorProjectionSchema } from "../contracts/errorSchemas.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { err } from "../domain/result.js";
+import { analysisErrorWithCleanupFailure } from "./binary/AnalysisClientCleanup.js";
+/** Await one-shot cleanup and retain either the outcome or both failures. */
+export const withSessionCleanup = async (session, operation, onCleanupFailure) => {
+    let value;
+    try {
+        value = await operation();
+    }
+    catch (cause) {
+        const closed = await session.close();
+        if (!closed.ok)
+            throw new AggregateError([cause, closed.error], "Analysis and provider cleanup both failed", { cause });
+        throw cause;
+    }
+    const closed = await session.close();
+    return closed.ok ? value : onCleanupFailure(value, closed.error);
+};
+/** Keep the primary CLI failure or completed Evidence alongside cleanup failure. */
+export const directAnalysisCleanupFailure = (output, error) => {
+    const cleanup = projectAnalysisError(error);
+    if (typeof output === "object" && output !== null && !Array.isArray(output)) {
+        const { error: label, ...projection } = output;
+        const primary = analysisErrorProjectionSchema.safeParse(projection);
+        if (typeof label === "string" && primary.success)
+            return {
+                error: label,
+                ...primary.data,
+                code: "cleanup_incomplete",
+                retryable: false,
+                details: {
+                    ...primary.data.details,
+                    cleanup: "incomplete",
+                    resources: error.cleanupResources.slice(),
+                    execution_failure: primary.data.details !== undefined &&
+                        "execution_failure" in primary.data.details
+                        ? (primary.data.details.execution_failure ?? primary.data.code)
+                        : primary.data.code,
+                    primary_error: projection,
+                    cleanup_error: cleanup,
+                },
+            };
+    }
+    return {
+        error: "Analysis failed",
+        ...cleanup,
+        code: "cleanup_incomplete",
+        retryable: false,
+        details: {
+            ...cleanup.details,
+            cleanup: "incomplete",
+            partial_observation: output,
+        },
+    };
+};
+/** Preserve managed observations or the original typed failure in diagnostics. */
+export const managedAnalysisCleanupFailure = (result, error) => {
+    if (!result.ok)
+        return err(analysisErrorWithCleanupFailure(result.error, error));
+    const cleanup = projectAnalysisError(error);
+    return err(new ProviderAdapterError(error instanceof ProviderAdapterError ? error.providerId : "rea", "close_binary", {
+        cause: error,
+        cleanup: { reason: cleanup.message, resources: error.cleanupResources },
+        diagnostics: {
+            cleanup_error: cleanup,
+            partial_observation: jsonValueSchema.parse(result.value),
+        },
+    }));
+};

package/dist/application/DirectAnalysisStatus.js

@@ -1,10 +1,9 @@
-import { parseConfig } from "../config.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { silentLogger } from "../logger.js";
-const runSessionStatus = async (dependencies, logger = silentLogger, environment = process.env) => {
-    const config = parseConfig(environment);
+const runSessionStatus = async (dependencies, logger = silentLogger) => {
+    const config = dependencies.readConfiguration();
     if (!config.ok)
         return { error: projectAnalysisError(config.error) };
     const session = dependencies.createBinarySession(config.value, logger);
@@ -21,6 +20,6 @@ const runSessionStatus = async (dependencies, logger = silentLogger, environment
     }
 };
 /** List binary-session provider candidates and auxiliary operation availability. */
-export const runProviderStatus = (dependencies, logger = silentLogger, environment = process.env) => runSessionStatus(dependencies, logger, environment);
+export const runProviderStatus = (dependencies, logger = silentLogger) => runSessionStatus(dependencies, logger);
 /** List binary-session operation descriptors; this is not the full MCP catalog. */
-export const runCapabilityStatus = (dependencies, logger = silentLogger, environment = process.env) => runSessionStatus(dependencies, logger, environment);
+export const runCapabilityStatus = (dependencies, logger = silentLogger) => runSessionStatus(dependencies, logger);

package/dist/application/Doctor.js

@@ -1,12 +1,13 @@
 import { constants } from "node:fs";
 import { access, readFile, readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { delimiter, join } from "node:path";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
+import { join } from "node:path";
 import { analysisErrorRemediationAction } from "../domain/analysisErrorPresentation.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { execFileOutput } from "../process/ExecFileOutput.js";
-import { probeHomebrew } from "./homebrew.js";
+import { installedCaskAppdir, probeHomebrew } from "./homebrew.js";
 import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
+import { canonicalSkillNeedsInstall } from "./SetupSkill.js";
 import { CATALOG_IDENTITY } from "../catalogIdentity.js";
 import { PRODUCT_IDENTITY, SDK_IDENTITY } from "../identity.js";
 import { readClientRegistrationStatuses, } from "./ClientRegistrationStatus.js";
@@ -61,7 +62,7 @@ const collectDoctorIdentity = async (host) => {
         checks: [
             ...(skillAligned ? [] : [skillIdentityCheck(installedSkillIdentity)]),
             ...registrations
-                .filter((registration) => registration.state !== "aligned")
+                .filter((registration) => registration.state !== "aligned" && registration.state !== "manual")
                 .map(registrationCheck),
         ],
         value: {
@@ -96,7 +97,7 @@ const collectDoctorIdentity = async (host) => {
 };
 const skillIdentityAligned = (identity) => identity?.version === PRODUCT_IDENTITY.skillVersion &&
     identity.toolCount === CATALOG_IDENTITY.counts.mcp_tools &&
-    identity.catalogDigest === CATALOG_IDENTITY.digests.combined_sha256;
+    identity.canonical;
 const skillIdentityCheck = (identity) => ({
     name: "skill:identity",
     ok: false,
@@ -114,23 +115,13 @@ 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 = {}) => {
     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 homeDirectory = homeDirectoryFromEnvironment(environment, platform);
     const commandEnvironment = { env: environment };
     return {
         platform,
@@ -179,15 +170,21 @@ export const systemDoctorHost = (options = {}) => {
         supportedLinuxHopper: linuxHopperBinarySupported,
         async brewHopperPath() {
             return probeHomebrew(async (command) => {
+                let caskroom;
                 try {
-                    const prefix = (await hostExecFileOutput(command, ["--prefix", "--cask", "hopper-disassembler"], commandEnvironment)).stdout.trim();
-                    return `${prefix}/Hopper Disassembler.app/Contents/MacOS/hopper`;
+                    // Without a cask argument, `--caskroom` does not load Homebrew's
+                    // cask API, so doctor writes no Homebrew cache files.
+                    caskroom = (await hostExecFileOutput(command, ["--caskroom"], commandEnvironment)).stdout.trim();
                 }
                 catch (cause) {
                     // best-effort cleanup: optional Homebrew probing; absence means uninstalled.
                     void cause;
                     return undefined;
                 }
+                const appdir = await installedCaskAppdir(caskroom, "hopper-disassembler", homeDirectory);
+                return appdir === undefined
+                    ? undefined
+                    : join(appdir, "Hopper Disassembler.app/Contents/MacOS/hopper");
             });
         },
         manualHopperPaths: () => manualHopperPaths(homeDirectory),
@@ -228,7 +225,7 @@ export const systemDoctorHost = (options = {}) => {
         }),
     };
 };
-const readMacosVersion = async (run = execFileOutput, options = { env: process.env }) => {
+const readMacosVersion = async (run, options) => {
     try {
         return (await run("sw_vers", ["-productVersion"], options)).stdout.trim();
     }
@@ -238,7 +235,7 @@ const readMacosVersion = async (run = execFileOutput, options = { env: process.e
         return undefined;
     }
 };
-const executableAvailable = async (path, platform = process.platform, run = execFileOutput, options = { env: process.env }) => {
+const executableAvailable = async (path, platform, run, options) => {
     try {
         await access(path, constants.X_OK);
         if (platform !== "linux")
@@ -259,7 +256,7 @@ 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 (home = homedir()) => {
+const manualHopperPaths = async (home) => {
     const paths = [];
     for (const root of ["/Applications", join(home, "Applications")]) {
         try {
@@ -281,6 +278,7 @@ const installedSkillIdentity = async (home) => {
         const content = await readInstalledSkill(home);
         const countText = /^\s{2}tool_count:\s*(\d+)\s*$/mu.exec(content)?.[1];
         return {
+            canonical: !(await canonicalSkillNeedsInstall(home)),
             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] ??

package/dist/application/DoctorDiagnostics.js

@@ -1,4 +1,3 @@
-import { homedir } from "node:os";
 import { SUPPORTED_NODE_VERSION_PROSE, supportsNodeVersion, } from "../domain/runtimeVersion.js";
 import { linuxHopperLauncherPath } from "./LinuxHopper.js";
 const DEFAULT_HOPPER = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
@@ -75,7 +74,7 @@ const findHopper = async (host) => {
         ? [
             DEFAULT_HOPPER,
             SYSTEM_LINUX_HOPPER,
-            linuxHopperLauncherPath(host.homeDirectory ?? homedir()),
+            linuxHopperLauncherPath(host.homeDirectory),
             ...(await host.manualHopperPaths()),
         ]
         : [host.configuredHopperPath];

package/dist/application/DoctorScope.js

@@ -1,4 +1,5 @@
 import { uniqueSorted } from "../domain/canonicalOrdering.js";
+import { manualRegistrationRemediation } from "./SupportedClients.js";
 /** Normalize a caller-selected doctor readiness boundary. */
 export const normalizeDoctorScope = (requested, target) => ({
     mode: requested === undefined ? "audit-wide" : "explicit",
@@ -62,22 +63,33 @@ const selectedProviderChecksFor = (providerId, checks, providers) => {
         },
     ];
 };
-const selectedRegistrationCheck = (client, status) => status === undefined
-    ? {
-        name: `registration:${client}`,
-        ok: false,
-        classification: "config_drift",
-        detail: `Requested client ${client} was not detected.`,
-        remediation: `Install or select ${client}, then run rea setup --client ${client}.`,
-    }
-    : status.state === "aligned"
+const selectedRegistrationCheck = (client, status) => {
+    const manual = manualRegistrationRemediation(client);
+    if (status === undefined && manual !== undefined)
+        return {
+            name: `registration:${client}`,
+            ok: false,
+            classification: "config_drift",
+            detail: `${client} is not registered through a local configuration file.`,
+            remediation: manual,
+        };
+    return status === undefined
         ? {
             name: `registration:${client}`,
-            ok: true,
-            classification: "healthy",
-            detail: status.config_path,
+            ok: false,
+            classification: "config_drift",
+            detail: `Requested client ${client} was not detected.`,
+            remediation: `Install or select ${client}, then run rea setup --client ${client}.`,
         }
-        : registrationCheck(status);
+        : status.state === "aligned"
+            ? {
+                name: `registration:${client}`,
+                ok: true,
+                classification: "healthy",
+                detail: status.config_path,
+            }
+            : registrationCheck(status);
+};
 const registrationCheck = (status) => ({
     name: `registration:${status.client}`,
     ok: false,