rea-agents 3.0.0 → 3.2.0

package/dist/application/ReconstructionObligationLedgerService.js

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
-import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerPageSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
+import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
 import { err, ok } from "../domain/result.js";
 import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
 import { deriveReconstructionObligationCandidates } from "./ReconstructionObligationCandidates.js";
@@ -15,7 +15,7 @@ export const resolveReconstructionObligationLedgerRequest = (input) => {
         ? ok(parsed.data)
         : err(new AnalysisInputError(OPERATION, { cause: parsed.error }));
 };
-/** Build one deterministic ledger page and wrap it in portable Evidence v2. */
+/** Build the complete deterministic ledger and wrap it in portable Evidence. */
 export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
     try {
         const generated = deriveReconstructionObligationCandidates(input.evidence_bundle, input.reviewed_obligations);
@@ -23,11 +23,9 @@ export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
             candidates: generated.candidates,
             bundle: input.evidence_bundle,
             manifest: input.manifest,
-            maxObligations: input.limits.max_obligations,
             generationLimitations: generated.limitations,
         });
-        const page = pageLedger(ledger, input.page.offset, input.page.limit);
-        return ok(createLedgerEvidence(input, page));
+        return ok(createLedgerEvidence(input, ledger));
     }
     catch (cause) {
         if (cause instanceof z.ZodError)
@@ -35,38 +33,21 @@ export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
         return err(new AnalysisProtocolError("Reconstruction obligation ledger generation failed", { cause }));
     }
 };
-const pageLedger = (ledger, offset, limit) => {
-    const obligations = ledger.obligations.slice(offset, offset + limit);
-    const nextOffset = offset + obligations.length < ledger.obligations.length
-        ? offset + obligations.length
-        : null;
-    const { obligations: _allObligations, ...summary } = ledger;
-    return reconstructionObligationLedgerPageSchema.parse({
-        ...summary,
-        page: {
-            offset,
-            limit,
-            total: ledger.obligations.length,
-            returned: obligations.length,
-            next_offset: nextOffset,
-        },
-        obligations,
+const createLedgerEvidence = (input, ledger) => {
+    const completeLedger = reconstructionObligationLedgerSchema.parse(ledger);
+    return createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
+        predicateType: "rea.reconstruction-obligation-ledger",
+        operation: OPERATION,
+        parameters: jsonObjectSchema.parse({
+            ledger_id: completeLedger.ledger_id,
+            closure_digest: completeLedger.closure_digest,
+        }),
+        result: jsonValueSchema.parse(completeLedger),
+        rawResult: null,
+        confidence: "inferred",
+        authority: "analyst-inference",
+        environment: null,
+        limitations: completeLedger.limitations,
+        evidenceLinks: completeLedger.evidence_links,
     });
 };
-const createLedgerEvidence = (input, page) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
-    predicateType: "rea.reconstruction-obligation-ledger/v1",
-    operation: OPERATION,
-    parameters: jsonObjectSchema.parse({
-        ledger_id: page.ledger_id,
-        closure_digest: page.closure_digest,
-        limits: input.limits,
-        page: input.page,
-    }),
-    result: jsonValueSchema.parse(page),
-    rawResult: null,
-    confidence: "inferred",
-    authority: "analyst-inference",
-    environment: null,
-    limitations: page.limitations,
-    evidenceLinks: page.evidence_links,
-});

package/dist/application/ReferenceSourceImport.js

@@ -1,23 +1,12 @@
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 import { isSecretLikePath } from "../domain/referenceSourceClassification.js";
-import { createHistoricalSourceGraph, historicalSourceParseFailureKey, } from "../domain/referenceSourceGraph.js";
+import { createHistoricalSourceGraph, historicalSourceLanguages, historicalSourceManifests, historicalSourceParseFailureKey, } from "../domain/referenceSourceGraph.js";
 import { err, ok } from "../domain/result.js";
 import { readReferenceSource } from "../reference/ReferenceSourceReader.js";
 import { parseReferenceSourceEntries } from "./ReferenceSourceImportEntries.js";
 import { readReferenceSourceVcs } from "./ReferenceSourceVcsAdapter.js";
 import {} from "./ReferenceSourceImportTypes.js";
 import { prepareReferenceSourceImport } from "./ReferenceSourceImportPolicy.js";
-const compareCodePoints = (left, right) => {
-    const leftPoints = [...left].map((value) => value.codePointAt(0) ?? 0);
-    const rightPoints = [...right].map((value) => value.codePointAt(0) ?? 0);
-    const length = Math.min(leftPoints.length, rightPoints.length);
-    for (let index = 0; index < length; index += 1) {
-        const difference = (leftPoints[index] ?? 0) - (rightPoints[index] ?? 0);
-        if (difference !== 0)
-            return difference;
-    }
-    return leftPoints.length - rightPoints.length;
-};
-const byCodePoint = (left, right) => compareCodePoints(left, right);
 const failure = (code, message) => ({
     tag: "reference-source-import",
     code,
@@ -40,7 +29,7 @@ const deduplicateRelationships = (relationships) => {
 };
 /** Sort parse failures deterministically while retaining distinct reasons. */
 export const normalizeHistoricalSourceParseFailures = (failures) => [...failures]
-    .sort((left, right) => byCodePoint(historicalSourceParseFailureKey(left), historicalSourceParseFailureKey(right)))
+    .sort((left, right) => compareUnicodeCodePoints(historicalSourceParseFailureKey(left), historicalSourceParseFailureKey(right)))
     .filter((value, index, array) => {
     if (index === 0)
         return true;
@@ -54,16 +43,6 @@ const buildProvenance = (options) => ({
     importer_version: options.importerVersion ?? null,
     caller: options.caller,
 });
-const deriveLanguages = (entries) => [
-    ...new Set(entries.flatMap((entry) => entry.kind === "file" && entry.language !== null
-        ? [entry.language]
-        : [])),
-].sort(byCodePoint);
-const deriveManifests = (entries) => entries
-    .flatMap((entry) => entry.kind === "file" && entry.classifications.includes("manifest")
-    ? [entry.path]
-    : [])
-    .sort(byCodePoint);
 const deriveInventoryState = (input) => {
     if (input.limitations.length > 0)
         return "partial";
@@ -83,17 +62,12 @@ const deriveInventoryState = (input) => {
         return "partial";
     return "complete";
 };
-const sortAndLimit = (exclusions, maxExclusions) => {
-    const sorted = [...exclusions].sort((left, right) => {
-        const byPath = byCodePoint(left.path, right.path);
-        if (byPath !== 0)
-            return byPath;
-        return byCodePoint(left.reason, right.reason);
-    });
-    if (sorted.length <= maxExclusions)
-        return sorted;
-    return sorted.slice(0, maxExclusions);
-};
+const sortExclusions = (exclusions) => [...exclusions].sort((left, right) => {
+    const byPath = compareUnicodeCodePoints(left.path, right.path);
+    if (byPath !== 0)
+        return byPath;
+    return compareUnicodeCodePoints(left.reason, right.reason);
+});
 /**
  * Import a reference source directory into a committed historical source graph.
  *
@@ -107,7 +81,7 @@ export const importReferenceSource = async (options) => {
     const prepared = await prepareReferenceSourceImport(options);
     if (!prepared.ok)
         return prepared;
-    const { ignored, limits, root, secrets } = prepared.value;
+    const { ignored, root, secrets } = prepared.value;
     if (isAborted(options.signal))
         return err(cancelled());
     const exclusions = [];
@@ -123,7 +97,7 @@ export const importReferenceSource = async (options) => {
         return false;
     };
     const [readResult, vcs] = await Promise.all([
-        readReferenceSource(root, limits, {
+        readReferenceSource(root, {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             shouldExclude,
         }),
@@ -133,7 +107,7 @@ export const importReferenceSource = async (options) => {
         const error = readResult.error;
         if (error.code === "cancelled")
             return err(cancelled());
-        return err(failure(error.code === "invalid-limits" ? "invalid-limits" : "io", error.message));
+        return err(failure("io", error.message));
     }
     if (isAborted(options.signal))
         return err(cancelled());
@@ -146,11 +120,11 @@ export const importReferenceSource = async (options) => {
         return err(cancelled());
     const uniqueRelationships = deduplicateRelationships(relationships);
     const uniqueFailures = normalizeHistoricalSourceParseFailures(parseFailures);
-    const sortedEntries = [...entries].sort((left, right) => byCodePoint(left.path, right.path));
-    const sortedExclusions = sortAndLimit(exclusions, limits.maxEntries);
-    const sortedLimitations = [...limitations].sort(byCodePoint);
+    const sortedEntries = [...entries].sort((left, right) => compareUnicodeCodePoints(left.path, right.path));
+    const sortedExclusions = sortExclusions(exclusions);
+    const sortedLimitations = [...limitations].sort(compareUnicodeCodePoints);
     const input = {
-        schema: "HistoricalSourceGraph/v1",
+        schema: "HistoricalSourceGraph",
         authority: "historical-reference",
         root_alias: "$REFERENCE_ROOT",
         inventory_state: deriveInventoryState({
@@ -161,11 +135,11 @@ export const importReferenceSource = async (options) => {
             limitations: sortedLimitations,
         }),
         entries: sortedEntries,
-        relationships: uniqueRelationships.sort((left, right) => byCodePoint(relationshipKey(left), relationshipKey(right))),
+        relationships: uniqueRelationships.sort((left, right) => compareUnicodeCodePoints(relationshipKey(left), relationshipKey(right))),
         parse_failures: uniqueFailures,
         exclusions: sortedExclusions,
-        languages: deriveLanguages(sortedEntries),
-        manifests: deriveManifests(sortedEntries),
+        languages: historicalSourceLanguages(sortedEntries),
+        manifests: historicalSourceManifests(sortedEntries),
         vcs,
         provenance: buildProvenance(options),
         limitations: sortedLimitations,
@@ -173,7 +147,7 @@ export const importReferenceSource = async (options) => {
     try {
         return ok(createHistoricalSourceGraph(input));
     }
-    catch (error) {
-        return err(failure("parse", error instanceof Error ? error.message : "Graph failed validation"));
+    catch (cause) {
+        return err(failure("parse", cause instanceof Error ? cause.message : "Graph failed validation"));
     }
 };

package/dist/application/ReferenceSourceImportEntries.js

@@ -7,8 +7,6 @@ import { PARSEABLE_REFERENCE_SOURCE_LANGUAGES } from "./ReferenceSourceImportTyp
 export const projectReferenceSourceEntryFailure = (entry) => {
     if (entry.code === "cancelled")
         return "This entry was not read because the import was cancelled. Start the import again when ready.";
-    if (entry.code === "limit")
-        return "This entry was not read because an import limit was reached. Import a smaller directory or raise the configured limits.";
     if (entry.code === "unsupported")
         return "This entry cannot be read safely on this system. Exclude it or import the directory on a supported system.";
     if (entry.kind === "directory")
@@ -26,7 +24,7 @@ const failedEntry = (entry) => {
             path: entry.path,
             kind: "directory",
             classifications,
-            tree_state: entry.code === "limit" ? "partial" : "unreadable",
+            tree_state: "unreadable",
             limitations: [limitation],
         };
     if (entry.kind === "symlink")
@@ -45,7 +43,7 @@ const failedEntry = (entry) => {
         size: entry.size ?? null,
         language: null,
         classifications: entry.kind === "file" ? classifications : ["unknown"],
-        content_state: entry.code === "limit" ? "too-large" : "unreadable",
+        content_state: "unreadable",
         limitations: [limitation],
     };
 };

package/dist/application/ReferenceSourceImportPolicy.js

@@ -2,40 +2,18 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import ignore from "ignore";
 import { err, ok } from "../domain/result.js";
-import { withinRoot } from "../reference/ReferenceSourceReaderPaths.js";
-import { DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS, DEFAULT_REFERENCE_SOURCE_LIMITS, } from "./ReferenceSourceImportTypes.js";
-import { canonicalizeConfiguredRoots } from "./ConfiguredRoots.js";
+import { DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS, } from "./ReferenceSourceImportTypes.js";
 const failure = (code, message) => ({
     tag: "reference-source-import",
     code,
     message,
 });
-const validLimits = (limits) => Object.values(limits).every((value) => Number.isSafeInteger(value) && value > 0);
-const maximumLimits = (options) => ({
-    maxBytes: options.policy.maxBytes,
-    maxEntries: options.policy.maxEntries,
-    maxDepth: options.policy.maxDepth,
-    maxPathBytes: options.policy.maxPathBytes,
-});
-const clampLimits = (requested, maximum) => ({
-    maxBytes: Math.min(requested.maxBytes, maximum.maxBytes),
-    maxEntries: Math.min(requested.maxEntries, maximum.maxEntries),
-    maxDepth: Math.min(requested.maxDepth, maximum.maxDepth),
-    maxPathBytes: Math.min(requested.maxPathBytes, maximum.maxPathBytes),
-});
-const authorizeRoot = async (requestedRoot, approvedRoots) => {
-    if (approvedRoots.length === 0)
-        return err(failure("policy", "No approved reference source roots"));
+const resolveRoot = async (requestedRoot) => {
     try {
         if (!(await stat(requestedRoot)).isDirectory())
             return err(failure("invalid-root", "Reference source root is not a directory"));
         const canonicalRoot = await realpath(resolve(requestedRoot));
-        const canonicalApprovedRoots = await canonicalizeConfiguredRoots(approvedRoots.map((approvedRoot) => resolve(approvedRoot)));
-        for (const canonicalApproved of canonicalApprovedRoots) {
-            if (withinRoot(canonicalApproved, canonicalRoot))
-                return ok(canonicalRoot);
-        }
-        return err(failure("policy", "Reference source root is outside approved roots"));
+        return ok(canonicalRoot);
     }
     catch {
         return err(failure("invalid-root", "Reference source root could not be resolved"));
@@ -56,18 +34,13 @@ const buildIgnored = async (root, excludePaths) => {
     }
     return ignored;
 };
-/** Validate limits, authorize root, and build non-executing path filters. */
+/** Resolve the caller-selected directory and build path filters. */
 export const prepareReferenceSourceImport = async (options) => {
-    const requested = options.limits ?? DEFAULT_REFERENCE_SOURCE_LIMITS;
-    const maximum = maximumLimits(options);
-    if (!validLimits(requested) || !validLimits(maximum))
-        return err(failure("invalid-limits", "Import limits must be positive integers"));
-    const root = await authorizeRoot(options.root, options.policy.roots);
+    const root = await resolveRoot(options.root);
     if (!root.ok)
         return root;
     return ok({
         root: root.value,
-        limits: clampLimits(requested, maximum),
         ignored: await buildIgnored(root.value, options.excludePaths ?? []),
         secrets: ignore().add([...options.policy.secretPatterns]),
     });

package/dist/application/ReferenceSourceImportTypes.js

@@ -5,21 +5,11 @@ export const projectReferenceSourceImportError = (error) => {
             category: "cancelled",
             message: "Reference source import was cancelled. Start it again when ready.",
         };
-    if (error.code === "invalid-limits")
-        return {
-            category: "invalid_input",
-            message: "Reference source limits are invalid. Use positive integer limits, then try again.",
-        };
     if (error.code === "invalid-root")
         return {
             category: "invalid_input",
             message: "Reference source directory could not be opened. Check that the path exists, is readable, and points to a directory.",
         };
-    if (error.code === "policy")
-        return {
-            category: "permission_required",
-            message: "Reference source directory is not approved. Add its directory to `REA_REFERENCE_ROOTS_JSON`, restart REA, then try again.",
-        };
     if (error.code === "io")
         return {
             category: "execution_failure",
@@ -41,10 +31,4 @@ export const DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS = [
     ".coverage",
     "*.log",
 ];
-export const DEFAULT_REFERENCE_SOURCE_LIMITS = {
-    maxBytes: 16 * 1024 * 1024,
-    maxEntries: 10_000,
-    maxDepth: 32,
-    maxPathBytes: 4_096,
-};
 export const PARSEABLE_REFERENCE_SOURCE_LANGUAGES = new Set(["JavaScript", "TypeScript", "JSX", "TSX"]);

package/dist/application/RuntimeExecutableDiagnostics.js

@@ -1,13 +1,10 @@
-import { execFile } from "node:child_process";
+import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access, realpath } from "node:fs/promises";
 import { delimiter, join } from "node:path";
 const TOOL_NAMES = ["node", "npm", "npx"];
-const MAX_CANDIDATES_PER_TOOL = 16;
-const MAX_OUTPUT_BYTES = 65_536;
-const MAX_DIAGNOSTIC_BYTES = 4_096;
 const PROBE_CONCURRENCY = 4;
-/** Inventory and bounded-probe Node toolchain candidates under one exact PATH. */
+/** Inventory and probe Node toolchain candidates under one exact PATH. */
 export const inspectRuntimeExecutables = async (options) => {
     const pathEntries = unique(options.path.split(delimiter).filter(Boolean));
     const candidates = [
@@ -37,7 +34,7 @@ export const inspectRuntimeExecutables = async (options) => {
         seen.add(key);
         uniqueCandidates.push(candidate);
     }
-    const diagnostics = await mapConcurrentBounded(uniqueCandidates, PROBE_CONCURRENCY, (candidate) => probeCandidate(candidate, options.timeoutMs ?? 5_000, options.path));
+    const diagnostics = await mapConcurrentBounded(uniqueCandidates, PROBE_CONCURRENCY, (candidate) => probeCandidate(candidate, options.timeoutMs, options.path));
     return {
         launcher_node: await canonicalPath(options.launcherNode),
         candidates: diagnostics,
@@ -56,47 +53,79 @@ const discoverToolCandidates = async (tool, pathEntries, platform, configuredExt
                 break;
             }
         }
-        if (candidates.length >= MAX_CANDIDATES_PER_TOOL)
-            break;
     }
     return candidates;
 };
 const probeCandidate = async (candidate, timeoutMs, effectivePath) => {
     const canonical = await canonicalPath(candidate.path);
     const result = await executeVersion(candidate.path, timeoutMs, effectivePath);
-    return {
+    const identity = {
         tool: candidate.tool,
         lexical_path: candidate.path,
         canonical_path: canonical,
         path_index: candidate.pathIndex,
         selection: candidate.selection,
-        version: result.ok ? result.version : null,
-        healthy: result.ok,
-        failure: result.ok ? null : result.failure,
     };
+    return result.ok
+        ? { ...identity, version: result.version, healthy: true, failure: null }
+        : {
+            ...identity,
+            version: null,
+            healthy: false,
+            failure: result.failure,
+        };
 };
 const executeVersion = (path, timeoutMs, effectivePath) => new Promise((resolve) => {
-    const child = execFile(path, ["--version"], {
-        encoding: "utf8",
-        timeout: timeoutMs,
-        maxBuffer: MAX_OUTPUT_BYTES,
+    const child = spawn(path, ["--version"], {
         windowsHide: true,
         env: environmentWithPath(effectivePath),
-    }, (cause, stdout, stderr) => {
-        if (cause === null) {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    let stdout = "";
+    let stderr = "";
+    let spawnError;
+    let timeout;
+    let timedOut = false;
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+        stdout += chunk;
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk;
+    });
+    child.once("error", (cause) => {
+        spawnError = cause;
+    });
+    if (timeoutMs !== undefined && timeoutMs > 0) {
+        timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, timeoutMs);
+        timeout.unref();
+    }
+    child.once("close", () => {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        if (spawnError === undefined && child.exitCode === 0) {
             const version = firstNonemptyLine(stdout) ?? firstNonemptyLine(stderr);
-            if (version !== undefined)
+            if (version !== undefined) {
                 resolve({ ok: true, version });
-            else
-                resolve({
-                    ok: false,
-                    failure: failure("runtime_invalid_version_output", child, stderr),
-                });
+                return;
+            }
+            resolve({
+                ok: false,
+                failure: failure("runtime_invalid_version_output", child, stderr),
+            });
             return;
         }
+        const cause = spawnError ??
+            new Error("Runtime version probe did not exit successfully");
         resolve({
             ok: false,
-            failure: classifyProbeFailure(cause, child, stderr),
+            failure: timedOut
+                ? failure("runtime_timeout", child, stderr)
+                : classifyProbeFailure(cause, child, stderr),
         });
     });
 });
@@ -117,7 +146,7 @@ const failure = (code, child, stderr, dependency = null) => ({
     exit_code: child.exitCode,
     signal: child.signalCode,
     dependency,
-    stderr: bounded(stderr.trim()),
+    stderr: stderr.trim(),
 });
 const missingDynamicLibrary = (stderr) => /(?:dyld(?:\[[^\]]+\])?: )?Library not loaded:\s*([^\r\n]+)/u
     .exec(stderr)?.[1]
@@ -143,9 +172,6 @@ const firstNonemptyLine = (value) => value
     .split(/\r?\n/u)
     .find((line) => line.trim().length > 0)
     ?.trim();
-const bounded = (value) => value.length <= MAX_DIAGNOSTIC_BYTES
-    ? value
-    : value.slice(-MAX_DIAGNOSTIC_BYTES);
 const unique = (values) => [...new Set(values)];
 const environmentWithPath = (path) => {
     const environment = {};

package/dist/application/SessionProviderRouter.js

@@ -11,8 +11,8 @@ export class SessionProviderRouter {
     constructor(runtime) {
         this.runtime = runtime;
     }
-    /** Preserve the existing provider/factory seam used by focused embedders. */
-    static legacy(provider, options = {}) {
+    /** Create routing for an embedding backed by one fixed provider or factory. */
+    static single(provider, options = {}) {
         const identity = typeof provider === "function"
             ? { id: "unidentified", name: "Unidentified provider", version: null }
             : provider.identity();

package/dist/application/Setup.js

@@ -13,8 +13,7 @@ import { discoverSetupActions } from "./SetupPlan.js";
 import { clientConfigurationAligned, configureJsonClient, configureTomlClient, inspectClientConfiguration, } from "./SetupClientConfiguration.js";
 export { configureJsonClient, configureTomlClient };
 import { setupInstallFailure, } from "./SetupInstallFailure.js";
-import { providerRegistrationEnvironment, registrationPermissionEnvironment, } from "./SetupRegistrationEnvironment.js";
-export { registrationPermissionEnvironment } from "./SetupRegistrationEnvironment.js";
+import { providerRegistrationEnvironment } from "./SetupRegistrationEnvironment.js";
 export { canonicalSkillNeedsInstall, installCanonicalSkill };
 const registrationCommand = () => process.env.npm_command === "exec"
     ? PRODUCT_IDENTITY.mcpCommand.split(" ")
@@ -254,7 +253,6 @@ export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
             const diagnosis = await runDoctor(undefined, doctorHost);
             return {
                 ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
-                ...registrationPermissionEnvironment(process.env),
                 ...(diagnosis.hopperPath === undefined
                     ? {}
                     : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),