rea-agents 6.1.0 → 6.3.0

package/dist/application/MacHopper.js

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
 import { access, mkdir, mkdtemp, readdir, rename, rm, writeFile, } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { z } from "zod";
+import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 const execFileAsync = promisify(execFile);
 const RELEASES_URL = "https://www.hopperapp.com/include/files-api.php?request=releases&public=true";
 const DOWNLOAD_PREFIX = "https://www.hopperapp.com:443/downloader/public/";
@@ -21,7 +22,7 @@ export const macHopperInstallDisclosure = {
     ],
 };
 /** Download, verify, and install Hopper into the current user's Applications directory. */
-export const installMacHopper = async (options = {}, host = systemMacHopperInstallHost()) => {
+export const installMacHopper = async (options = {}, host = systemMacHopperInstallHost(homeDirectoryFromEnvironment(process.env, process.platform), process.env)) => {
     let temporary;
     let mounted = false;
     try {
@@ -77,7 +78,8 @@ export const installMacHopper = async (options = {}, host = systemMacHopperInsta
         }
     }
 };
-const systemMacHopperInstallHost = () => ({
+/** Compose installer paths and subprocesses from one selected caller context. */
+export const systemMacHopperInstallHost = (homeDirectory, environment) => ({
     download: downloadPackage,
     createTemporaryDirectory: () => mkdtemp(join(tmpdir(), "rea-hopper-mac-")),
     createMountDirectory: (path) => mkdir(path),
@@ -90,10 +92,10 @@ const systemMacHopperInstallHost = () => ({
             "-mountpoint",
             mountPath,
             packagePath,
-        ]);
+        ], environment);
     },
     async unmount(mountPath) {
-        await commandSucceeds("hdiutil", ["detach", mountPath, "-force"]);
+        await commandSucceeds("hdiutil", ["detach", mountPath, "-force"], environment);
     },
     async appBundle(mountPath) {
         const entries = await readdir(mountPath, { withFileTypes: true });
@@ -101,19 +103,14 @@ const systemMacHopperInstallHost = () => ({
         return app === undefined ? undefined : join(mountPath, app.name);
     },
     async validBundle(appPath) {
-        if (!(await commandSucceeds("codesign", [
-            "--verify",
-            "--deep",
-            "--strict",
-            appPath,
-        ])))
+        if (!(await commandSucceeds("codesign", ["--verify", "--deep", "--strict", appPath], environment)))
             return false;
         try {
             const identifier = (await execFileAsync("/usr/libexec/PlistBuddy", [
                 "-c",
                 "Print :CFBundleIdentifier",
                 join(appPath, "Contents/Info.plist"),
-            ])).stdout.trim();
+            ], { env: environment })).stdout.trim();
             return identifier === BUNDLE_IDENTIFIER;
         }
         catch (cause) {
@@ -136,10 +133,10 @@ const systemMacHopperInstallHost = () => ({
     async installBundle(source, destination, stage, replaceExisting) {
         const previous = `${stage}-previous`;
         try {
-            await mkdir(join(homedir(), "Applications"), { recursive: true });
+            await mkdir(join(homeDirectory, "Applications"), { recursive: true });
             await rm(stage, { recursive: true, force: true });
             await rm(previous, { recursive: true, force: true });
-            await execFileAsync("ditto", [source, stage]);
+            await execFileAsync("ditto", [source, stage], { env: environment });
             await access(join(stage, "Contents/MacOS/hopper"));
             if (replaceExisting)
                 await rename(destination, previous);
@@ -176,10 +173,10 @@ const systemMacHopperInstallHost = () => ({
         }
     },
     async openApplication(path) {
-        await execFileAsync("open", [path]);
+        await execFileAsync("open", [path], { env: environment });
     },
     cleanup: (path) => rm(path, { recursive: true, force: true }),
-    destination: () => join(homedir(), "Applications/Hopper Disassembler.app"),
+    destination: () => join(homeDirectory, "Applications/Hopper Disassembler.app"),
 });
 const downloadPackage = async (url) => {
     const response = await fetch(url, {
@@ -196,9 +193,9 @@ const parseJson = (bytes) => JSON.parse(new TextDecoder().decode(bytes));
 const integrityMatches = (bytes, release) => bytes.byteLength === Number(release.file_length) &&
     bytes.byteLength <= MAX_PACKAGE_BYTES &&
     createHash("sha1").update(bytes).digest("hex") === release.file_hash;
-const commandSucceeds = async (command, args) => {
+const commandSucceeds = async (command, args, environment) => {
     try {
-        await execFileAsync(command, args);
+        await execFileAsync(command, args, { env: environment });
         return true;
     }
     catch (cause) {

package/dist/application/RealHopperAssertions.js

@@ -11,17 +11,6 @@ export const firstProcedureAddress = (input) => {
         throw new TypeError("Procedure inventory was empty");
     return first.address;
 };
-/** Reject two target paths that resolve to the same binary content. */
-export const requireDistinctTargetHashes = (firstHash, secondHash) => {
-    if (typeof firstHash !== "string" ||
-        typeof secondHash !== "string" ||
-        firstHash.length === 0 ||
-        secondHash.length === 0) {
-        throw new TypeError("Target hashes must be non-empty strings");
-    }
-    if (firstHash === secondHash)
-        throw new TypeError("Real-Hopper verification requires distinct binaries");
-};
 /** Reject empty and success-shaped embedded decompilation failures. */
 export const requirePseudocode = (input, operation) => {
     if (typeof input !== "string" || input.trim().length === 0)

package/dist/application/ReconstructionObligationCandidates.js

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { parseEvidenceBundle, } from "../domain/evidenceBundle.js";
-import { parseProcessCapture } from "../domain/process/processCapture.js";
+import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
+import { resolveJavaScriptSemanticEvidence } from "../domain/javascript/javascriptSemanticGraph.js";
 import { parseApplicationGraphEvidence } from "./javascript/JavaScriptApplicationEvidenceGraph.js";
 import { applicationObligationPolicy, semanticObligationPolicy, } from "./ReconstructionObligationPolicies.js";
 /** Derive conservative candidates from graph, process, and reviewed inputs. */
@@ -29,7 +30,12 @@ const deriveApplicationCandidates = (evidence, records, candidates, limitations)
     ].includes(evidence.operation))
         return;
     try {
-        const source = parseApplicationGraphEvidence(evidence);
+        const parsed = parseApplicationGraphEvidence(evidence);
+        if (!parsed.ok) {
+            limitations.add(`Application Evidence ${evidence.evidence_id} could not generate candidates because it failed graph validation.`);
+            return;
+        }
+        const source = parsed.value;
         for (const node of source.graph.nodes) {
             const candidatePolicy = applicationObligationPolicy(node.kind);
             if (candidatePolicy === undefined) {
@@ -54,6 +60,7 @@ const deriveApplicationCandidates = (evidence, records, candidates, limitations)
                 const candidatePolicy = semanticObligationPolicy(node.kind);
                 if (candidatePolicy === undefined)
                     continue;
+                const evidenceContext = resolveJavaScriptSemanticEvidence(source.semanticGraph, node.evidence);
                 addCandidate(candidates, generatedCandidate({
                     key: `semantic:${node.node_id}:${candidatePolicy.family}`,
                     title: node.label ?? `${node.kind} semantic boundary`,
@@ -63,7 +70,7 @@ const deriveApplicationCandidates = (evidence, records, candidates, limitations)
                     semanticNodeId: node.node_id,
                     location: `semantic-graph:${source.semanticGraph.graph_id}/nodes/${node.node_id}`,
                     authorityReferences: [
-                        graphReference(evidence, records, node.evidence, `${source.semanticGraph.graph_id}/node/${node.node_id}`),
+                        graphReference(evidence, records, evidenceContext, `${source.semanticGraph.graph_id}/node/${node.node_id}`),
                     ],
                 }));
             }

package/dist/application/ReconstructionObligationLedgerProjection.js

@@ -1,5 +1,7 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
+import { canonicalJson } from "../domain/comparisonSemantics.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 export const obligationLedgerCoverage = (incomplete) => ({
     status: incomplete ? "partial" : "complete",
 });
@@ -64,7 +66,7 @@ export const obligationLedgerStatus = (obligations) => {
         return "unknown";
     return requiredOpen.length === 0 ? "ready" : "open";
 };
-export const obligationEdgeOrder = (left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right));
+export const obligationEdgeOrder = (left, right) => compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right));
 export const digestObligationLedgerValue = (value) => {
     const encoded = canonicalize(value);
     if (encoded === undefined)

package/dist/application/ReferenceSourceImportEntries.js

@@ -32,7 +32,7 @@ const failedEntry = (entry) => {
         return {
             path: entry.path,
             kind: "symlink",
-            target: "<unreadable>",
+            target: null,
             target_state: "unreadable",
             classifications,
             limitations: [limitation],

package/dist/application/RegularFileRead.js

@@ -0,0 +1,17 @@
+import { openRegularFile } from "../filesystem/RegularFile.js";
+/** Admit one regular-file handle, retain it through the consumer, and always close it. */
+export const withRegularFile = async (path, read, signal) => {
+    const handle = await openRegularFile(path, { symlinks: "follow", signal });
+    try {
+        const stats = await handle.stat();
+        signal?.throwIfAborted();
+        const value = await read(handle, stats);
+        signal?.throwIfAborted();
+        return value;
+    }
+    finally {
+        await handle.close();
+    }
+};
+/** Admit a regular file without waiting for a pipe, then read its verified handle. */
+export const readRegularFile = (path, signal) => withRegularFile(path, (handle) => handle.readFile({ signal }), signal);

package/dist/application/Setup.js

@@ -1,7 +1,7 @@
 import { manualRegistrationRemediation, } from "./SupportedClients.js";
 import { configureDetectedClients } from "./SetupClients.js";
 import { discoverSetupState, planSetupActions } from "./SetupPlan.js";
-import { filterClientsNeedingConfigure, hostRemediation, initialProviderEnvironment, setupRegistrationCommand, systemSetupHost, } from "./SetupHost.js";
+import { filterClientsNeedingConfigure, hostRemediation, systemSetupHost, } from "./SetupHost.js";
 /** Discover, approve, and apply setup actions idempotently. */
 export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     const appliedActions = [];
@@ -13,22 +13,14 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     const unsupported = await hostRemediation(host, false);
     if (unsupported !== undefined)
         return fail(unsupported);
-    const initialState = await host.initialSetupState?.(options.readinessScope);
-    let hopperPath = initialState === undefined
-        ? await host.hopperPath()
-        : initialState.hopperPath;
-    let providerEnvironment = initialState === undefined
-        ? await initialProviderEnvironment(host, hopperPath)
-        : initialState.providerEnvironment;
+    const initialState = await host.initialSetupState(options.readinessScope);
+    let { hopperPath, providerEnvironment } = initialState;
     const discovery = await discoverSetupState({
         host,
         providerEnvironment,
         forceHopperInstall: options.installHopper,
         proposeHopper: options.proposeHopper ?? (confirm !== undefined && !options.structured),
-        doctorScope: options.readinessScope,
-        ...(initialState === undefined
-            ? {}
-            : { initialDoctor: initialState.doctor }),
+        initialDoctor: initialState.doctor,
     });
     clientStates = discovery.clientStates;
     const clientSelectionAllowed = options.clientIds === undefined &&
@@ -42,18 +34,27 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
         : (options.clientIds ??
             options.readinessScope?.clients ??
             discovery.defaultClientIds);
+    let skillNeedsInstall = await host.skillNeedsInstall(selectedClientIds);
     let skillSelected = options.installSkill === true ||
         (options.installSkill !== false && selectedClientIds.length > 0);
-    let installSkill = skillSelected && discovery.skillNeedsInstall;
+    let installSkill = skillSelected && skillNeedsInstall;
     let planDiscovery = discovery;
     if (interactiveSelection) {
-        const offerSkillAction = options.installSkill !== false && discovery.skillNeedsInstall;
+        const selectionSkillClientIds = [
+            ...new Set([
+                ...discovery.defaultClientIds,
+                ...discovery.detectedClientIds,
+            ]),
+        ];
+        const selectionSkillNeedsInstall = await host.skillNeedsInstall(selectionSkillClientIds);
+        const offerSkillAction = options.installSkill !== false && selectionSkillNeedsInstall;
         const selectionActions = await planSetupActions({
             discovery,
             host,
             providerEnvironment,
-            command: setupRegistrationCommand(host.platform),
+            command: host.registrationCommand,
             clientIds: [],
+            skillClientIds: selectionSkillClientIds,
             installSkill: offerSkillAction,
         });
         const decision = await confirm(selectionActions.plannedActions, {
@@ -75,6 +76,7 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
         selectedClientIds = [...selectedActionIds]
             .filter((id) => id.startsWith("configure_client:"))
             .map((id) => id.slice("configure_client:".length));
+        skillNeedsInstall = await host.skillNeedsInstall(selectedClientIds);
         const proposedInstallAction = selectionActions.plannedActions.some(({ id }) => id === "install_hopper");
         planDiscovery = {
             ...discovery,
@@ -86,14 +88,15 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
                 (selectedActionIds.has("install_skill") &&
                     selectedClientIds.length === 0) ||
                 (options.installSkill !== false && selectedClientIds.length > 0);
-        installSkill = skillSelected && discovery.skillNeedsInstall;
+        installSkill = skillSelected && skillNeedsInstall;
     }
     const planned = await planSetupActions({
         discovery: planDiscovery,
         host,
         providerEnvironment,
-        command: setupRegistrationCommand(host.platform),
+        command: host.registrationCommand,
         clientIds: selectedClientIds,
+        skillClientIds: selectedClientIds,
         installSkill,
     });
     plannedActions = planned.plannedActions;
@@ -175,7 +178,7 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
         host,
         detectedClients: selectedClients,
         providerEnvironment,
-        command: setupRegistrationCommand(host.platform),
+        command: host.registrationCommand,
         clients,
         appliedActions,
         ...(options.onProgress === undefined
@@ -185,8 +188,8 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     if (clientFailure !== undefined)
         return fail(clientFailure);
     if (planSelection.installSkill &&
-        !(await installSkillAction(host, options, appliedActions)))
-        return fail("REA analysis skill could not be installed or verified. Check permissions for `~/.agents/skills`, then rerun setup.");
+        !(await installSkillAction(host, options, appliedActions, selectedClientIds)))
+        return fail("REA analysis skill could not be installed or verified. Check permissions for its planned skill directories, then rerun setup.");
     const doctor = summarizeDoctor(await host.doctor(readinessScope));
     const remediation = combineRemediation(finalSetupRemediation(host.platform, appliedActions.includes("installed_hopper"), doctor.healthy, hopperPath), manualRemediation);
     return {
@@ -241,17 +244,17 @@ const installHopperAction = async (input) => {
     return {
         hopperPath: installed.launcherPath,
         providerEnvironment,
-        selectedClients: await filterClientsNeedingConfigure(input.host, input.selectedClients, providerEnvironment, setupRegistrationCommand(input.host.platform)),
+        selectedClients: await filterClientsNeedingConfigure(input.host, input.selectedClients, providerEnvironment, input.host.registrationCommand),
     };
 };
-const installSkillAction = async (host, options, appliedActions) => {
+const installSkillAction = async (host, options, appliedActions, skillClientIds) => {
     const label = "REA reverse-engineering skill";
     emitProgress(options, {
         actionId: "install_skill",
         label,
         state: "started",
     });
-    const skill = await host.installSkill();
+    const skill = await host.installSkill(skillClientIds);
     if (skill === "failed") {
         emitProgress(options, {
             actionId: "install_skill",

package/dist/application/SetupClientConfiguration.js

@@ -1,4 +1,4 @@
-import { clientRegistrationEntry, clientConfigurationValuesEqual, clientServerPath, grokServerListedDisabled, legacyClientServerPath, parseClientConfiguration, serializeClientConfiguration, withClientServers, } from "./ClientConfigurationDocument.js";
+import { clientRegistrationEntry, clientConfigurationValuesEqual, clientServerListedDisabled, clientServerPath, legacyClientServerPath, OMP_DISABLED_SERVERS_KEY, parseClientConfiguration, serializeClientConfiguration, withClientServers, } from "./ClientConfigurationDocument.js";
 import { constants as fsConstants } from "node:fs";
 import { copyFile, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
@@ -7,9 +7,8 @@ import { PRODUCT_IDENTITY } from "../identity.js";
 import { npxRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { MCP_STARTUP_POLICY } from "../mcpStartupPolicy.js";
 import { resolveClientConfigTransactionPath } from "./ClientConfigPath.js";
-const defaultCommand = () => npxRegistrationCommand();
 /** Configure one supported client's native stdio MCP registration shape. */
-export const configureClientConfiguration = (client, environment = {}, command = defaultCommand()) => {
+export const configureClientConfiguration = (client, environment = {}, command = npxRegistrationCommand()) => {
     if (client.format === undefined || client.format === "unsupported")
         return Promise.resolve({ status: "failed", reason: "readback" });
     return configureClientDocument(client, environment, command, client.format);
@@ -45,12 +44,25 @@ const configureClientDocument = async (client, environment, command, format) =>
     // A native OpenCode V2 entry replaces REA's legacy V1 entry, which would
     // otherwise conflict with it.
     const legacyPath = legacyClientServerPath(parsed, PRODUCT_IDENTITY.mcpServerKey);
-    const document = withClientServers(parsed, { ...parsed.servers, [PRODUCT_IDENTITY.mcpServerKey]: desired }, PRODUCT_IDENTITY.mcpServerKey);
+    const registered = withClientServers(parsed, { ...parsed.servers, [PRODUCT_IDENTITY.mcpServerKey]: desired }, PRODUCT_IDENTITY.mcpServerKey);
+    // OMP's denylist would hide the registration; keep every other listed name.
+    const ompDisabled = parsed.dialect === "omp"
+        ? parsed.document[OMP_DISABLED_SERVERS_KEY]
+        : undefined;
+    const enableOmp = Array.isArray(ompDisabled) &&
+        ompDisabled.includes(PRODUCT_IDENTITY.mcpServerKey);
+    const document = enableOmp && Array.isArray(ompDisabled)
+        ? {
+            ...registered,
+            [OMP_DISABLED_SERVERS_KEY]: ompDisabled.filter((name) => name !== PRODUCT_IDENTITY.mcpServerKey),
+        }
+        : registered;
     try {
         await mkdir(dirname(client.configPath), { recursive: true });
         await writeFileAtomic(transactionPath, serializeClientConfiguration(document, format, original, [
             clientServerPath(parsed, PRODUCT_IDENTITY.mcpServerKey),
             ...(legacyPath === undefined ? [] : [legacyPath]),
+            ...(enableOmp ? [[OMP_DISABLED_SERVERS_KEY]] : []),
         ]), {
             encoding: "utf8",
             mode: 0o600,
@@ -155,11 +167,10 @@ const restoreConfig = async (path, original) => {
         void cause;
     }
 };
-/** Whether REA's entry matches, no legacy entry remains, and Grok is not suppressing it. */
+/** Whether REA's entry matches, no legacy entry remains, and no client disable list suppresses it. */
 const registrationCurrent = (parsed, desired) => clientConfigurationValuesEqual(parsed.servers[PRODUCT_IDENTITY.mcpServerKey], desired) &&
     !Object.hasOwn(parsed.legacyServers, PRODUCT_IDENTITY.mcpServerKey) &&
-    !(parsed.dialect === "grok" &&
-        grokServerListedDisabled(parsed.document, PRODUCT_IDENTITY.mcpServerKey));
+    !clientServerListedDisabled(parsed, PRODUCT_IDENTITY.mcpServerKey);
 const clientConfigurationDesired = (client, providerEnvironment, command, format) => {
     const environment = Object.fromEntries(Object.entries(providerEnvironment).sort(([left], [right]) => left.localeCompare(right)));
     const registration = clientRegistrationEntry(format ?? "json", command.length === 0 ? [PRODUCT_IDENTITY.cliBinary, "mcp"] : command, environment);

package/dist/application/SetupHost.js

@@ -1,19 +1,18 @@
 import { access } from "node:fs/promises";
-import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { npxRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { SUPPORTED_NODE_VERSION_PROSE, supportsNodeVersion, } from "../domain/runtimeVersion.js";
 import { runDoctor, systemDoctorHost } from "./Doctor.js";
-import { installLinuxHopper, readLinuxDistribution } from "./LinuxHopper.js";
-import { installMacHopper } from "./MacHopper.js";
+import { installLinuxHopper, readLinuxDistribution, systemLinuxHopperInstallHost, } from "./LinuxHopper.js";
+import { installMacHopper, systemMacHopperInstallHost } from "./MacHopper.js";
 import { supportedClients } from "./SupportedClients.js";
-import { canonicalSkillNeedsInstall, installCanonicalSkill, } from "./SetupSkill.js";
+import { claudeCodeSkillsDirectory as resolveClaudeCodeSkillsDirectory, 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
+export const setupRegistrationCommand = (platform, useNpmRunner) => useNpmRunner
     ? npxRegistrationCommand(platform)
     : platform === "win32"
         ? [
@@ -26,10 +25,6 @@ export const filterClientsNeedingConfigure = async (host, detectedClients, provi
     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 ${SUPPORTED_NODE_VERSION_PROSE} and rerun setup.`;
@@ -45,17 +40,22 @@ export const hostRemediation = async (host, installHopper) => {
     }
     if ((await host.linuxDistribution())?.supported === true)
         return undefined;
-    return "Automated Hopper setup supports Ubuntu 24.04+, Fedora 41+, 64-bit Arch Linux, and CachyOS; configure an existing supported provider instead.";
+    return "Automated Hopper setup supports Ubuntu 24.04+, Fedora 41+, Nobara 44+, 64-bit Arch Linux, and CachyOS; configure an existing supported provider instead.";
 };
 /** Production setup effects for Hopper, agent configuration, and the canonical skill directory. */
-export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
+export const systemSetupHost = (selectedDoctorHost = undefined, environment = process.env) => {
+    const doctorHost = selectedDoctorHost ?? systemDoctorHost({ environment });
     const platform = doctorHost.platform;
+    const { homeDirectory } = doctorHost;
+    const claudeSkillsDirectory = resolveClaudeCodeSkillsDirectory(homeDirectory, environment);
     return {
         platform,
+        homeDirectory,
+        claudeCodeSkillsDirectory: claudeSkillsDirectory,
+        registrationCommand: setupRegistrationCommand(platform, environment.npm_command === "exec"),
         nodeVersion: process.versions.node,
         macosVersion: () => doctorHost.macosVersion(),
         linuxDistribution: readLinuxDistribution,
-        hopperPath: async () => (await runDoctor(undefined, doctorHost)).hopperPath,
         initialSetupState: async (scope) => {
             const diagnosis = await runDoctor(undefined, doctorHost, scope);
             return {
@@ -71,25 +71,16 @@ export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
                 doctor: diagnosis,
             };
         },
-        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 });
+                ? await installLinuxHopper(systemLinuxHopperInstallHost(environment))
+                : await installMacHopper({ replaceExisting }, systemMacHopperInstallHost(homeDirectory, environment));
             if (result.status === "installed")
                 return result;
             return setupInstallFailure(result.reason);
         },
-        detectedClients: () => detectClients(homedir()),
-        supportedClients: () => Promise.resolve(supportedClients(homedir())),
+        detectedClients: () => detectClients(homeDirectory, platform, environment),
+        supportedClients: () => Promise.resolve(supportedClients(homeDirectory, platform, environment)),
         configureClient: (client, providerEnvironment, command) => client.format === "unsupported"
             ? Promise.resolve({ status: "skipped" })
             : configureClientConfiguration(client, providerEnvironment, command),
@@ -97,15 +88,15 @@ export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
             ? Promise.resolve(false)
             : clientConfigurationAligned(client, providerEnvironment, command).then((aligned) => !aligned),
         inspectClientConfiguration: inspectClientConfiguration,
-        skillNeedsInstall: () => canonicalSkillNeedsInstall(homedir()),
-        installSkill: () => installCanonicalSkill(homedir()),
+        skillNeedsInstall: (clientIds) => canonicalSkillNeedsInstall(homeDirectory, clientIds, claudeSkillsDirectory),
+        installSkill: (clientIds) => installCanonicalSkill(homeDirectory, clientIds, claudeSkillsDirectory),
         doctor: (scope) => runDoctor(undefined, doctorHost, scope),
     };
 };
 /** Detect supported agents from their config files or stable installation markers. */
-export const detectClients = async (home) => {
+export const detectClients = async (home, platform = process.platform, environment = process.env) => {
     const detected = [];
-    for (const candidate of supportedClients(home)) {
+    for (const candidate of supportedClients(home, platform, environment)) {
         const [hasConfig, hasMarker] = await Promise.all([
             exists(candidate.configPath),
             candidate.markerPath === undefined ? false : exists(candidate.markerPath),

package/dist/application/SetupPlan.js

@@ -1,12 +1,11 @@
-import { homedir } from "node:os";
 import { join } from "node:path";
-import { PRODUCT_IDENTITY } from "../identity.js";
 import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { linuxHopperInstallDisclosure, } from "./LinuxHopper.js";
+import { skillDestinations } from "./SetupSkill.js";
 import { macHopperInstallDisclosure } from "./MacHopper.js";
 /** Discover supported clients and current registrations without mutation. */
 export const discoverSetupState = async (input) => {
-    const initialDoctor = input.initialDoctor ?? (await input.host.doctor(input.doctorScope));
+    const { initialDoctor } = input;
     const linuxHopperRepairNeeded = initialDoctor.checks.some(({ name, ok, detail }) => !ok &&
         (name === "hopper-demo-runtime" ||
             (name === "hopper-version" && detail === "/opt/hopper/bin/Hopper")));
@@ -21,10 +20,9 @@ export const discoverSetupState = async (input) => {
             input.proposeHopper &&
             (Object.keys(input.providerEnvironment).length === 0 ||
                 linuxHopperRepairNeeded));
-    const [clients, detectedClients, skillNeedsInstall] = await Promise.all([
-        input.host.supportedClients?.() ?? input.host.detectedClients(),
+    const [clients, detectedClients] = await Promise.all([
+        input.host.supportedClients(),
         input.host.detectedClients(),
-        input.host.skillNeedsInstall(),
     ]);
     const detectedIds = new Set(detectedClients.map(({ name }) => name));
     const registrations = initialDoctor.identity?.registrations ?? [];
@@ -57,7 +55,6 @@ export const discoverSetupState = async (input) => {
     return {
         initialDoctor,
         installHopper,
-        skillNeedsInstall,
         clients,
         detectedClientIds: [...detectedIds],
         defaultClientIds,
@@ -85,7 +82,7 @@ export const planSetupActions = async (input) => {
     });
     const inspections = await Promise.all(selectedClients.map(async (client) => ({
         client,
-        inspection: (await input.host.inspectClientConfiguration?.(client, input.providerEnvironment, input.command)) ?? { status: "update" },
+        inspection: await input.host.inspectClientConfiguration(client, input.providerEnvironment, input.command),
     })));
     const invalid = inspections.find(({ inspection }) => inspection.status === "invalid");
     if (invalid?.inspection.status === "invalid") {
@@ -117,8 +114,11 @@ export const planSetupActions = async (input) => {
     return {
         plannedActions: setupPlan({
             platform: input.host.platform,
+            homeDirectory: input.host.homeDirectory,
             installHopper: input.discovery.installHopper,
             installSkill: input.installSkill,
+            skillClientIds: input.skillClientIds,
+            claudeCodeSkillsDirectory: input.host.claudeCodeSkillsDirectory,
             clients: clientPlans,
             providerEnvironment: input.providerEnvironment,
             ...(input.discovery.linuxPackageFamily === undefined
@@ -139,7 +139,7 @@ const setupPlan = (input) => [
                 kind: "install_hopper",
                 label: "Hopper deep-analysis provider",
                 target: input.platform === "darwin"
-                    ? join(homedir(), "Applications/Hopper Disassembler.app")
+                    ? join(input.homeDirectory, "Applications/Hopper Disassembler.app")
                     : "system package manager",
                 detail: input.platform === "linux"
                     ? "Download, verify, and install Hopper plus its Xvfb demo-session dependencies. For the supported demo build, REA uses a private display and selects Hopper's offered demo mode for each analysis session."
@@ -170,17 +170,21 @@ const setupPlan = (input) => [
         ...(backupPath === undefined ? {} : { backupPath }),
     })),
     ...(input.installSkill
-        ? [
-            {
-                id: "install_skill",
-                kind: "install_skill",
-                label: "REA reverse-engineering skill",
-                target: join(homedir(), ".agents/skills", PRODUCT_IDENTITY.skillName),
-                detail: "Install or update the bundled REA reverse-engineering skill and on-demand references.",
-                external: false,
-                operation: "install",
-            },
-        ]
+        ? skillDestinations(input.homeDirectory, input.skillClientIds, input.claudeCodeSkillsDirectory).map(({ client, path }) => ({
+            id: client === "claude_code"
+                ? "install_skill:claude_code"
+                : "install_skill",
+            kind: "install_skill",
+            label: client === "claude_code"
+                ? "REA skill for Claude Code"
+                : "REA reverse-engineering skill",
+            target: path,
+            detail: client === "claude_code"
+                ? "Install or update the REA skill in Claude Code's personal skill directory."
+                : "Install or update the bundled REA reverse-engineering skill and on-demand references.",
+            external: false,
+            operation: "install",
+        }))
         : []),
 ];
 const linuxDisclosure = (family) => {