rea-agents 6.2.0 → 6.3.0

package/dist/application/DirectAnalysis.js

@@ -75,6 +75,7 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
         const prepared = await prepareSnapshot({
             path,
             snapshotPath,
+            signal,
             ...(options.formatHint === undefined
                 ? {}
                 : { formatHint: options.formatHint }),
@@ -144,7 +145,7 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
         if (evidence !== undefined) {
             const recorded = session.recordEvidence(evidence);
             if (!recorded.ok)
-                return cliError(recorded.error);
+                return cliError(recorded.error.retainPartialObservation(evidence));
             if (isWorkflowEvidenceTool(tool)) {
                 const unknowns = recordWorkflowUnknowns({
                     name: tool,
@@ -153,7 +154,7 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
                     recordUnknown: (unknown) => session.recordUnknown(unknown),
                 });
                 if (!unknowns.ok)
-                    return cliError(unknowns.error);
+                    return cliError(unknowns.error.retainPartialObservation(evidence));
             }
         }
         if (isWorkflowEvidenceTool(tool) &&
@@ -165,7 +166,7 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
             if (workflowRecord !== undefined) {
                 const recorded = session.recordWorkflowSnapshot(workflowRecord);
                 if (!recorded.ok)
-                    return cliError(recorded.error);
+                    return cliError(recorded.error.retainPartialObservation(evidence));
             }
         }
         if (tool !== "trace_native_ui_action" &&
@@ -173,10 +174,10 @@ const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
             evidence !== undefined) {
             const snapshot = session.exportAnalysisSnapshot();
             if (!snapshot.ok)
-                return cliError(snapshot.error);
+                return cliError(snapshot.error.retainPartialObservation(evidence));
             const written = await writeAnalysisSnapshot(snapshot.value, snapshotPath, true);
             if (!written.ok)
-                return cliError(written.error);
+                return cliError(written.error.retainPartialObservation(evidence));
         }
         return output;
     }, directAnalysisCleanupFailure);
@@ -266,7 +267,12 @@ const prepareSnapshot = async (options) => {
     const loaded = await readAnalysisSnapshot(snapshotPath);
     if (!loaded.ok)
         return loaded;
-    const target = await parseBinaryTarget(path, process.cwd(), process.arch, undefined, options.formatHint);
+    const target = await parseBinaryTarget(path, {
+        signal: options.signal,
+        ...(options.formatHint === undefined
+            ? {}
+            : { formatHint: options.formatHint }),
+    });
     if (!target.ok)
         return target;
     if (!snapshotMatchesTarget(loaded.value.target, target.value))

package/dist/application/DirectAnalysisCleanup.js

@@ -39,7 +39,6 @@ export const directAnalysisCleanupFailure = (output, error) => {
                         "execution_failure" in primary.data.details
                         ? (primary.data.details.execution_failure ?? primary.data.code)
                         : primary.data.code,
-                    primary_error: projection,
                     cleanup_error: cleanup,
                 },
             };

package/dist/application/DirectAnalysisStatus.js

@@ -2,7 +2,8 @@ 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) => {
+/** Read target-free provider status and operation availability. */
+export const runSessionStatus = async (dependencies, logger = silentLogger) => {
     const config = dependencies.readConfiguration();
     if (!config.ok)
         return { error: projectAnalysisError(config.error) };
@@ -19,7 +20,3 @@ const runSessionStatus = async (dependencies, logger = silentLogger) => {
         await session.close();
     }
 };
-/** List binary-session provider candidates and auxiliary operation availability. */
-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) => runSessionStatus(dependencies, logger);

package/dist/application/Doctor.js

@@ -1,13 +1,14 @@
 import { constants } from "node:fs";
-import { access, readFile, readdir } from "node:fs/promises";
+import { access, readdir } from "node:fs/promises";
 import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 import { join } from "node:path";
 import { analysisErrorRemediationAction } from "../domain/analysisErrorPresentation.js";
+import { BinaryTargetError } from "../domain/configurationErrors.js";
 import { parseBinaryTarget } from "./BinaryTargetResolver.js";
 import { execFileOutput } from "../process/ExecFileOutput.js";
 import { installedCaskAppdir, probeHomebrew } from "./homebrew.js";
 import { linuxHopperBinarySupported, linuxSharedLibrariesAvailable, readLinuxDistribution, } from "./LinuxHopper.js";
-import { canonicalSkillNeedsInstall } from "./SetupSkill.js";
+import { claudeCodeSkillsDirectory, readInstalledSkillIdentity, } from "./SetupSkill.js";
 import { CATALOG_IDENTITY } from "../catalogIdentity.js";
 import { PRODUCT_IDENTITY, SDK_IDENTITY } from "../identity.js";
 import { readClientRegistrationStatuses, } from "./ClientRegistrationStatus.js";
@@ -21,8 +22,9 @@ export const DOCTOR_PROVIDER_IDS = ["hopper", "ghidra", "ida"];
  * or an agent consuming the structured result.
  */
 export const runDoctor = async (target, host = systemDoctorHost(), requestedScope) => {
+    const scope = normalizeDoctorScope(requestedScope, target);
     const { checks: diagnosticChecks, hopperPath, providerInspections, } = await collectDoctorDiagnostics(target, host);
-    const identity = await collectDoctorIdentity(host);
+    const identity = await collectDoctorIdentity(host, scope);
     const checks = [...diagnosticChecks, ...identity.checks];
     const providers = {
         hopperAvailable: hopperPath !== undefined &&
@@ -33,7 +35,6 @@ export const runDoctor = async (target, host = systemDoctorHost(), requestedScop
         providerInspections,
     };
     const environmentHealthy = doctorHealthy(checks, providers);
-    const scope = normalizeDoctorScope(requestedScope, target);
     const scoped = scopeDoctorChecks({
         checks,
         registrations: identity.value.registrations,
@@ -53,11 +54,14 @@ export const runDoctor = async (target, host = systemDoctorHost(), requestedScop
         identity: identity.value,
     };
 };
-const collectDoctorIdentity = async (host) => {
+const collectDoctorIdentity = async (host, scope) => {
     const installationPaths = (await host.installationPaths?.()) ?? [];
-    const installedSkillIdentity = await host.installedSkillIdentity?.();
-    const skillAligned = skillIdentityAligned(installedSkillIdentity);
     const registrations = (await host.clientRegistrations?.()) ?? [];
+    const skillClientIds = scope.mode === "audit-wide"
+        ? registrations.map(({ client }) => client)
+        : scope.clients;
+    const installedSkillIdentity = await host.installedSkillIdentity?.(skillClientIds);
+    const skillAligned = skillIdentityAligned(installedSkillIdentity);
     return {
         checks: [
             ...(skillAligned ? [] : [skillIdentityCheck(installedSkillIdentity)]),
@@ -81,7 +85,6 @@ const collectDoctorIdentity = async (host) => {
             skill: {
                 installed_version: installedSkillIdentity?.version ?? null,
                 installed_tool_count: installedSkillIdentity?.toolCount ?? null,
-                installed_catalog_digest: installedSkillIdentity?.catalogDigest ?? null,
                 state: installedSkillIdentity === undefined
                     ? "missing"
                     : skillAligned
@@ -137,10 +140,16 @@ export const systemDoctorHost = (options = {}) => {
         macosVersion: () => readMacosVersion(hostExecFileOutput, commandEnvironment),
         linuxDistribution: readLinuxDistribution,
         async validTarget(path) {
-            return (await parseBinaryTarget(path, process.cwd(), architecture)).ok;
+            return (await parseBinaryTarget(path, {
+                cwd: process.cwd(),
+                hostArchitecture: architecture,
+            })).ok;
         },
         async inspectTarget(path) {
-            const result = await parseBinaryTarget(path, process.cwd(), architecture);
+            const result = await parseBinaryTarget(path, {
+                cwd: process.cwd(),
+                hostArchitecture: architecture,
+            });
             if (result.ok)
                 return {
                     name: "target",
@@ -149,18 +158,19 @@ export const systemDoctorHost = (options = {}) => {
                     detail: path,
                 };
             const error = result.error;
+            const targetError = error instanceof BinaryTargetError ? error : undefined;
             return {
                 name: "target",
                 ok: false,
-                classification: error.constraint === "directory_requires_file"
+                classification: targetError?.constraint === "directory_requires_file"
                     ? "unsupported_target"
                     : "config_drift",
                 detail: path,
                 details: {
-                    reason: error.reason,
-                    ...(error.constraint === undefined
+                    reason: targetError?.reason ?? error.message,
+                    ...(targetError?.constraint === undefined
                         ? {}
-                        : { constraint: error.constraint }),
+                        : { constraint: targetError.constraint }),
                 },
                 remediation: analysisErrorRemediationAction(error),
             };
@@ -218,7 +228,7 @@ export const systemDoctorHost = (options = {}) => {
                 return [];
             }
         },
-        installedSkillIdentity: () => installedSkillIdentity(homeDirectory),
+        installedSkillIdentity: (clientIds) => readInstalledSkillIdentity(homeDirectory, clientIds, claudeCodeSkillsDirectory(homeDirectory, environment)),
         clientRegistrations: () => readClientRegistrationStatuses(homeDirectory, undefined, {
             platform,
             environment,
@@ -272,25 +282,6 @@ const manualHopperPaths = async (home) => {
     }
     return paths;
 };
-const readInstalledSkill = (home) => readFile(join(home, ".agents/skills", PRODUCT_IDENTITY.skillName, "SKILL.md"), "utf8");
-const installedSkillIdentity = async (home) => {
-    try {
-        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] ??
-                null,
-        };
-    }
-    catch (cause) {
-        // best-effort cleanup: optional skill probing; failure means unknown.
-        void cause;
-        return undefined;
-    }
-};
 const uniqueLines = (value) => [
     ...new Set(value
         .split(/\r?\n/u)

package/dist/application/DoctorDiagnostics.js

@@ -65,7 +65,7 @@ const hostCheck = async (host) => {
             ? `${host.platform} ${host.architecture}`
             : `${linuxDistribution.id} ${linuxDistribution.versionId ?? "unknown"}`);
     return check("host", supported, detail, {
-        remediation: "REA supports macOS 12+, Ubuntu 24.04+, Fedora 41+, 64-bit Arch Linux, CachyOS, and the experimental Windows x64 Ghidra P0 boundary.",
+        remediation: "REA supports macOS 12+, Ubuntu 24.04+, Fedora 41+, Nobara 44+, 64-bit Arch Linux, CachyOS, and the experimental Windows x64 Ghidra P0 boundary.",
         classification: "unsupported_host",
     });
 };

package/dist/application/EvidenceBundleFiles.js

@@ -1,7 +1,7 @@
 import { describeEvidenceBundleFailure, describeValidationFailure, parseEvidenceBundle, } from "../domain/evidenceBundle.js";
 import { EvidenceFileError, EvidenceIntegrityError, } from "../domain/evidenceErrors.js";
 import { err, ok } from "../domain/result.js";
-import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, } from "../domain/analysisErrorCore.js";
 import { parseProcessCapture } from "../domain/process/processCaptureParsing.js";
 import { bufferedJsonParts, canonicalJsonParts, } from "../domain/jsonSerialization.js";
 import { readJsonFile, writeTextParts } from "./JsonFiles.js";

package/dist/application/InvestigationProviders.js

@@ -13,17 +13,17 @@ export const workflowAnalysisProfile = (upstream, operation) => createAnalysisPr
         : {}),
 });
 /** Provider identity for deterministic artifact inventories. */
-export const ARTIFACT_GRAPH_PROVIDER = {
+export const ARTIFACT_GRAPH_PROVIDER = Object.freeze({
     id: "rea-artifact-graph",
     name: "REA safe artifact graph provider",
     version: "1",
-};
+});
 /** Provider identity for execution-free managed PE/CLI analysis. */
-export const MANAGED_STATIC_PROVIDER = {
+export const MANAGED_STATIC_PROVIDER = Object.freeze({
     id: "rea-dotnet-static",
     name: "REA managed static analysis provider",
     version: "1",
-};
+});
 /** Provider identity for deterministic managed-code comparison workflows. */
 export const MANAGED_WORKFLOW_PROVIDER = {
     id: "rea-dotnet-workflows",

package/dist/application/JsonFiles.js

@@ -1,31 +1,31 @@
-import { link, lstat, mkdtemp, open, readFile, realpath, rename, rm, } from "node:fs/promises";
+import { link, lstat, mkdtemp, open, realpath, rename, rm, } from "node:fs/promises";
 import { basename, dirname, resolve } from "node:path";
 import { EvidenceFileError } from "../domain/evidenceErrors.js";
-import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisResourceConstraintError, } from "../domain/analysisErrorCore.js";
 import { err, ok } from "../domain/result.js";
+import { parseUtf8Json } from "./Utf8JsonInput.js";
+import { readRegularFile } from "./RegularFileRead.js";
+import { NonRegularFileReadError } from "../filesystem/RegularFile.js";
 /** Read JSON data from a regular file at the caller-supplied path. */
 export const readJsonFile = async (path) => {
     const requestedPath = resolve(path);
     try {
-        const canonicalPath = await realpath(requestedPath);
-        const stats = await lstat(canonicalPath);
-        if (!stats.isFile())
-            return err(new EvidenceFileError("read", "not-file", { path: requestedPath }));
-        const encoded = await readFile(canonicalPath);
-        let decoded;
-        try {
-            decoded = JSON.parse(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(encoded));
-        }
-        catch (cause) {
+        const encoded = await readRegularFile(requestedPath);
+        const decoded = parseUtf8Json(encoded, "read_evidence_file", requestedPath);
+        if (!decoded.ok) {
             return err(new EvidenceFileError("read", "invalid-json", {
-                cause,
+                cause: decoded.cause,
                 path: requestedPath,
             }));
         }
-        return ok(decoded);
+        return ok(decoded.value);
     }
     catch (cause) {
-        return err(new EvidenceFileError("read", missingOrIo(cause), {
+        if (cause instanceof AnalysisResourceConstraintError)
+            return err(cause);
+        return err(new EvidenceFileError("read", cause instanceof NonRegularFileReadError
+            ? "not-file"
+            : missingOrIo(cause), {
             cause,
             path: requestedPath,
         }));

package/dist/application/LinuxHopper.js

@@ -63,7 +63,8 @@ export const parseLinuxDistribution = (text) => {
         (id === "arch" ||
             id === "cachyos" ||
             (id === "ubuntu" && versionAtLeast(versionId, 24)) ||
-            (id === "fedora" && versionAtLeast(versionId, 41)));
+            (id === "fedora" && versionAtLeast(versionId, 41)) ||
+            (id === "nobara" && versionAtLeast(versionId, 44)));
     const identity = {
         id,
         ...(versionId === undefined ? {} : { versionId }),

package/dist/application/ReconstructionObligationCandidates.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
 import { parseEvidenceBundle, } from "../domain/evidenceBundle.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/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

@@ -34,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: host.registrationCommand,
             clientIds: [],
+            skillClientIds: selectionSkillClientIds,
             installSkill: offerSkillAction,
         });
         const decision = await confirm(selectionActions.plannedActions, {
@@ -67,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,
@@ -78,7 +88,7 @@ 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,
@@ -86,6 +96,7 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
         providerEnvironment,
         command: host.registrationCommand,
         clientIds: selectedClientIds,
+        skillClientIds: selectedClientIds,
         installSkill,
     });
     plannedActions = planned.plannedActions;
@@ -177,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 {
@@ -236,14 +247,14 @@ const installHopperAction = async (input) => {
         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

@@ -7,7 +7,7 @@ import { runDoctor, systemDoctorHost } from "./Doctor.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";
@@ -40,16 +40,18 @@ 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 = (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(),
@@ -86,8 +88,8 @@ export const systemSetupHost = (selectedDoctorHost = undefined, environment = pr
             ? Promise.resolve(false)
             : clientConfigurationAligned(client, providerEnvironment, command).then((aligned) => !aligned),
         inspectClientConfiguration: inspectClientConfiguration,
-        skillNeedsInstall: () => canonicalSkillNeedsInstall(homeDirectory),
-        installSkill: () => installCanonicalSkill(homeDirectory),
+        skillNeedsInstall: (clientIds) => canonicalSkillNeedsInstall(homeDirectory, clientIds, claudeSkillsDirectory),
+        installSkill: (clientIds) => installCanonicalSkill(homeDirectory, clientIds, claudeSkillsDirectory),
         doctor: (scope) => runDoctor(undefined, doctorHost, scope),
     };
 };