rea-agents 6.1.0 → 6.3.0

package/dist/application/ClientConfigurationDocument.js

@@ -302,7 +302,7 @@ const isBlankOrComment = (line) => {
 };
 const looksLikeTomlHeader = (line) => line.trimStart().startsWith("[");
 /** `mcp_servers.<server>` and tables nested under it, compared by key segment. */
-const isGrokServerTable = (path, serverKey) => path[0] === "mcp_servers" && path[1] === serverKey;
+const isTomlServerTable = (path, serverKey) => path[0] === "mcp_servers" && path[1] === serverKey;
 const parseKeyPath = (text, start) => {
     const segments = [];
     let index = start;
@@ -486,7 +486,7 @@ const hasSeparatorComma = (trivia) => trivia.split("\n").some((part) => {
  * Replace or remove `serverKey` inside one `{ ... }` table. A closed inline
  * table cannot later grow a `[mcp_servers.rea]` header.
  */
-const editGrokInlineTable = (table, serverKey, entry) => {
+const editInlineServerTable = (table, serverKey, entry) => {
     if (!table.startsWith("{"))
         return undefined;
     const end = endOfContainer(table, 0);
@@ -667,10 +667,12 @@ const disabledServerListLines = (edit, lines, lineIndex, endLine) => {
     }
 };
 /**
- * Replace REA's Grok server tables and assignments. Comments that introduce a
- * following table stay. Text inside strings is not treated as a header.
+ * Replace REA's TOML server tables and assignments. Comments that introduce a
+ * following table stay. Codex also retains comments around REA's own table.
+ * Text inside strings is not treated as a header. Only Grok Build reads the
+ * root `disabled_mcp_servers` list that registration also edits.
  */
-const upsertGrokServerSection = (originalText, serverKey, entry) => {
+const upsertTomlServerSection = (originalText, serverKey, entry, format) => {
     // smol-toml accepts a leading BOM. Leave it in place or the first header is missed.
     const bom = originalText.startsWith("\uFEFF");
     const source = bom ? originalText.slice(1) : originalText;
@@ -721,7 +723,7 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
         const header = parseTomlTableHeader(line);
         if (header !== undefined) {
             tablePath = header.path;
-            if (isGrokServerTable(header.path, serverKey)) {
+            if (isTomlServerTable(header.path, serverKey)) {
                 discardPending();
                 skipping = true;
                 lineIndex += 1;
@@ -748,17 +750,19 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
                 mode = "none";
                 continue;
             }
-            const disabledLines = disabledServerListLines(disabledServerListEdit({
-                text,
-                lineStart,
-                valueOffset,
-                valueEnd,
-                statementEnd,
-                tablePath,
-                segments: assignment.segments,
-                serverKey,
-                entry,
-            }), lines, lineIndex, endLine);
+            const disabledLines = format === "grok"
+                ? disabledServerListLines(disabledServerListEdit({
+                    text,
+                    lineStart,
+                    valueOffset,
+                    valueEnd,
+                    statementEnd,
+                    tablePath,
+                    segments: assignment.segments,
+                    serverKey,
+                    entry,
+                }), lines, lineIndex, endLine)
+                : undefined;
             if (disabledLines !== undefined) {
                 flushPending();
                 kept.push(...disabledLines);
@@ -771,10 +775,10 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
             const closesServerTable = absolute.length === 1 &&
                 absolute[0] === "mcp_servers" &&
                 text[open] === "{";
-            if (closesServerTable || isGrokServerTable(absolute, serverKey)) {
+            if (closesServerTable || isTomlServerTable(absolute, serverKey)) {
                 if (closesServerTable) {
                     flushPending();
-                    const edited = editGrokInlineTable(text.slice(open, valueEnd), serverKey, entry);
+                    const edited = editInlineServerTable(text.slice(open, valueEnd), serverKey, entry);
                     const prefix = text.slice(lineStart, open);
                     const suffix = text.slice(valueEnd, statementEnd);
                     const replacement = edited === undefined
@@ -796,7 +800,12 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
             continue;
         }
         if (isBlankOrComment(line)) {
-            pending.push(physical);
+            if (format === "toml" && line.trimStart().startsWith("#")) {
+                flushPending();
+                kept.push(physical);
+            }
+            else
+                pending.push(physical);
             lineIndex += 1;
             continue;
         }
@@ -840,7 +849,7 @@ const upsertGrokServerSection = (originalText, serverKey, entry) => {
     }
     return bom ? `\uFEFF${body}` : body;
 };
-const grokServerEntry = (document, serverKey) => {
+const tomlServerEntry = (document, serverKey) => {
     const servers = objectSchema.safeParse(document.mcp_servers);
     if (!servers.success || !Object.hasOwn(servers.data, serverKey))
         return undefined;
@@ -849,12 +858,74 @@ const grokServerEntry = (document, serverKey) => {
 /** Whether Grok Build's root disable list names `serverKey`. */
 export const grokServerListedDisabled = (document, serverKey) => Array.isArray(document.disabled_mcp_servers) &&
     document.disabled_mcp_servers.includes(serverKey);
+/**
+ * OMP's user `disabledServers` denylist hides a server by name regardless of
+ * its entry, so a listed REA registration is not loaded.
+ */
+export const OMP_DISABLED_SERVERS_KEY = "disabledServers";
+/** Whether OMP's root `disabledServers` denylist names `serverKey`. */
+export const ompServerListedDisabled = (document, serverKey) => {
+    const listed = document[OMP_DISABLED_SERVERS_KEY];
+    return Array.isArray(listed) && listed.includes(serverKey);
+};
+/** OMP's user `enabledServers` allowlist overrides an entry's `enabled: false`. */
+const OMP_ENABLED_SERVERS_KEY = "enabledServers";
+/**
+ * Whether OMP's allowlist forces `serverKey` on despite its entry's
+ * `enabled: false`. The `disabledServers` denylist still wins over it.
+ */
+export const clientServerForcedEnabled = (parsed, serverKey) => {
+    if (parsed.dialect !== "omp")
+        return false;
+    const listed = parsed.document[OMP_ENABLED_SERVERS_KEY];
+    return Array.isArray(listed) && listed.includes(serverKey);
+};
+/** Whether a client's own disable list suppresses `serverKey`. */
+export const clientServerListedDisabled = (parsed, serverKey) => (parsed.dialect === "grok" &&
+    grokServerListedDisabled(parsed.document, serverKey)) ||
+    (parsed.dialect === "omp" &&
+        ompServerListedDisabled(parsed.document, serverKey));
 /** Keep an existing Grok document intact aside from the REA server tables. */
 const serializeGrokConfiguration = (document, originalText) => {
-    const entry = grokServerEntry(document, PRODUCT_IDENTITY.mcpServerKey);
+    const entry = tomlServerEntry(document, PRODUCT_IDENTITY.mcpServerKey);
     if (originalText === undefined)
         return stringifyToml(document);
-    return upsertGrokServerSection(originalText, PRODUCT_IDENTITY.mcpServerKey, entry);
+    return upsertTomlServerSection(originalText, PRODUCT_IDENTITY.mcpServerKey, entry, "grok");
+};
+/** Removing the last server leaves an empty table, which equals an absent one. */
+const withoutEmptyServerTable = (document) => {
+    const servers = objectSchema.safeParse(document.mcp_servers);
+    if (!servers.success || Object.keys(servers.data).length > 0)
+        return document;
+    const { mcp_servers: empty, ...rest } = document;
+    void empty;
+    return rest;
+};
+/**
+ * Keep an existing Codex document intact aside from the REA server tables.
+ * An edit that would change any other parsed value falls back to a full
+ * rewrite, which keeps every value but not comments or spelling.
+ */
+const serializeCodexConfiguration = (document, originalText) => {
+    if (originalText === undefined ||
+        isEmptyClientConfigurationText(originalText))
+        return stringifyToml(document);
+    const upserted = upsertTomlServerSection(originalText, PRODUCT_IDENTITY.mcpServerKey, tomlServerEntry(document, PRODUCT_IDENTITY.mcpServerKey), "toml");
+    // Removing a final table also drops the file's last line break.
+    const edited = originalText.endsWith("\n") && !upserted.endsWith("\n")
+        ? `${upserted}${originalText.endsWith("\r\n") ? "\r\n" : "\n"}`
+        : upserted;
+    return tomlTextHolds(edited, document) ? edited : stringifyToml(document);
+};
+const tomlTextHolds = (text, document) => {
+    try {
+        return clientConfigurationValuesEqual(withoutEmptyServerTable(objectSchema.parse(parseToml(text))), withoutEmptyServerTable(document));
+    }
+    catch (cause) {
+        // An unparsable edit is rejected in favor of the full rewrite.
+        void cause;
+        return false;
+    }
 };
 /** Comments in the trivia between two properties. `undefined` when there are none. */
 const commentsBetweenProperties = (gap) => {
@@ -952,12 +1023,12 @@ const deleteJsonPropertyPreservingComments = (text, path) => {
         suffix += "\n";
     return `${text.slice(0, previous.offset + previous.length)}${suffix}${remainder}`;
 };
-/** Serialize a validated client document, retaining JSONC comments. */
+/** Serialize a validated client document, retaining JSONC and TOML comments. */
 export const serializeClientConfiguration = (document, format, originalText, editedPaths) => {
     if (format === undefined || format === "unsupported")
         throw new TypeError("client does not have a supported MCP config format");
     if (format === "toml")
-        return stringifyToml(document);
+        return serializeCodexConfiguration(document, originalText);
     if (format === "grok")
         return serializeGrokConfiguration(document, originalText);
     // An empty original holds no comments or settings to preserve. Writing a
@@ -1007,6 +1078,7 @@ export const clientRegistrationEntry = (format, command, environment) => {
                     : { environment: { ...environment } }),
             };
         case "vscode":
+        case "omp":
             return {
                 type: "stdio",
                 command: executable,

package/dist/application/ClientRegistrationStatus.js

@@ -1,4 +1,4 @@
-import { effectiveClientServer, grokServerListedDisabled, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
+import { clientServerForcedEnabled, clientServerListedDisabled, effectiveClientServer, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { access, readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { z } from "zod";
@@ -29,7 +29,11 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
             CODEX_HOME: options.environment.CODEX_HOME,
             COPILOT_HOME: options.environment.COPILOT_HOME,
             GROK_HOME: options.environment.GROK_HOME,
+            OMP_PROFILE: options.environment.OMP_PROFILE,
             OPENCODE_CONFIG: options.environment.OPENCODE_CONFIG,
+            PI_CODING_AGENT_DIR: options.environment.PI_CODING_AGENT_DIR,
+            PI_CONFIG_DIR: options.environment.PI_CONFIG_DIR,
+            PI_PROFILE: options.environment.PI_PROFILE,
             SAND_DATA_ROOT: options.environment.SAND_DATA_ROOT,
             XDG_CONFIG_HOME: options.environment.XDG_CONFIG_HOME,
         })) {
@@ -61,9 +65,8 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
                 registration.command,
                 ...registration.args,
             ];
-            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client, currentCommandPath, options.platform ?? process.platform) &&
-                !(client.format === "grok" &&
-                    grokServerListedDisabled(parsed.document, PRODUCT_IDENTITY.mcpServerKey))
+            statuses.push(configuredStatus(client.name, client.configPath, command, registrationAligned(registration, client, currentCommandPath, options.platform ?? process.platform, clientServerForcedEnabled(parsed, PRODUCT_IDENTITY.mcpServerKey)) &&
+                !clientServerListedDisabled(parsed, PRODUCT_IDENTITY.mcpServerKey)
                 ? "aligned"
                 : "stale"));
         }
@@ -73,9 +76,10 @@ export const readClientRegistrationStatuses = async (home, currentCommandPath =
     }
     return statuses.sort((left, right) => left.client.localeCompare(right.client));
 };
-const registrationAligned = (registration, client, currentCommandPath, platform) => {
+const registrationAligned = (registration, client, currentCommandPath, platform, forcedEnabled = false) => {
     const command = [registration.command, ...registration.args];
-    if (registration.disabled === true || registration.enabled === false)
+    if (registration.disabled === true ||
+        (registration.enabled === false && !forcedEnabled))
         return false;
     if (!isOwnedClientRegistrationCommand(command, currentCommandPath))
         return false;
@@ -85,6 +89,11 @@ const registrationAligned = (registration, client, currentCommandPath, platform)
         return false;
     if (client.format === "vscode" && registration.type !== "stdio")
         return false;
+    // OMP infers stdio for a command entry without an explicit type.
+    if (client.format === "omp" &&
+        registration.type !== undefined &&
+        registration.type !== "stdio")
+        return false;
     if (client.format === "copilot_cli" &&
         (registration.type !== "stdio" ||
             JSON.stringify(registration.tools) !== JSON.stringify(["*"])))
@@ -127,6 +136,10 @@ const parseRegistration = (value, client) => {
         throw new TypeError("Expected an stdio registration");
     if (client.format === "commandcode" && registration.transport !== "stdio")
         throw new TypeError("Expected an stdio registration");
+    if (client.format === "omp" &&
+        registration.type !== undefined &&
+        registration.type !== "stdio")
+        throw new TypeError("Expected an stdio registration");
     return registration;
 };
 const remediation = "Run rea setup to refresh this registration, then restart the client.";

package/dist/application/DirectAnalysis.js

@@ -1,4 +1,3 @@
-import { parseConfig } from "../config.js";
 import { EnhancedTools } from "./EnhancedTools.js";
 import { executeFunctionAnalysisEvidence } from "./FunctionAnalysisEvidence.js";
 import { silentLogger } from "../logger.js";
@@ -15,6 +14,9 @@ import { err, ok } from "../domain/result.js";
 import { REA_WORKFLOW_PROVIDER, workflowAnalysisProfile, } from "./InvestigationProviders.js";
 import { createWorkflowEvidence, workflowSnapshotRecord, recordWorkflowUnknowns, } from "./WorkflowEvidence.js";
 import { artifactInspectionResultSchema } from "../domain/artifactInspection.js";
+import { resolveXrefsAddress } from "./XrefsAddressResolution.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { directAnalysisCleanupFailure, managedAnalysisCleanupFailure, withSessionCleanup, } from "./DirectAnalysisCleanup.js";
 /**
  * Open one binary, execute one tool, and always release provider resources.
  * Unlike MCP mode, every CLI invocation is intentionally isolated and does not
@@ -42,15 +44,12 @@ export const runProviderAnalysis = async (dependencies, ...[path, tool, argument
 /** Execute managed metadata inspection in an isolated managed-only session. */
 export const runManagedProviderExecution = async (dependencies, path, tool, signal) => withProcessCancellation(signal, async (operationSignal) => {
     const session = dependencies.createManagedBinarySession();
-    try {
+    return withSessionCleanup(session, async () => {
         const opened = await session.open(path, { signal: operationSignal });
         if (!opened.ok)
             return opened;
         return await session.execute(tool, {}, { signal: operationSignal });
-    }
-    finally {
-        await session.close();
-    }
+    }, managedAnalysisCleanupFailure);
 });
 const runManagedProviderAnalysis = async (dependencies, path, tool, signal) => {
     const execution = await runManagedProviderExecution(dependencies, path, tool, signal);
@@ -68,14 +67,15 @@ const runManagedProviderAnalysis = async (dependencies, path, tool, signal) => {
 };
 const runAnalysis = async (dependencies, path, tool, arguments_, options) => {
     const { logger, signal, snapshotPath } = options;
-    const config = parseConfig(options.environment ?? process.env);
+    const config = dependencies.readConfiguration();
     if (!config.ok)
         return cliError(config.error);
     const session = dependencies.createBinarySession(config.value, logger);
-    try {
+    return withSessionCleanup(session, async () => {
         const prepared = await prepareSnapshot({
             path,
             snapshotPath,
+            signal,
             ...(options.formatHint === undefined
                 ? {}
                 : { formatHint: options.formatHint }),
@@ -145,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,
@@ -154,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) &&
@@ -166,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" &&
@@ -174,16 +174,13 @@ 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;
-    }
-    finally {
-        await session.close();
-    }
+    }, directAnalysisCleanupFailure);
 };
 const executeAnalysisTool = async (input) => {
     const { session, tool, signal, evidenceProfile } = input;
@@ -211,7 +208,22 @@ const executeAnalysisTool = async (input) => {
         });
         return { output: evidence, evidence };
     }
-    const result = await session.execute(tool, input.arguments, { signal });
+    let result = await session.execute(tool, input.arguments, { signal });
+    if (tool === "xrefs" &&
+        typeof input.arguments.address === "string" &&
+        !result.ok &&
+        result.error instanceof AnalysisInputError &&
+        !result.error.cleanupIncomplete &&
+        result.error.issues.length > 0 &&
+        result.error.issues.every(({ path, reason }) => path.length === 1 &&
+            path[0] === "address" &&
+            reason === "invalid_format")) {
+        const address = await resolveXrefsAddress(session, input.arguments.address, signal);
+        if (!address.ok)
+            return { output: cliError(address.error) };
+        if (address.value !== input.arguments.address)
+            result = await session.execute(tool, { ...input.arguments, address: address.value }, { signal });
+    }
     if (!result.ok)
         return { output: cliError(result.error) };
     const evidence = createEvidence(result.value.subject ?? input.openedTarget, result.value.provider, {
@@ -236,12 +248,16 @@ const withProcessCancellation = async (suppliedSignal, operation) => {
         return operation(suppliedSignal);
     const controller = new AbortController();
     const cancel = () => controller.abort();
-    process.once("SIGINT", cancel);
+    // Package runners can forward a terminal interrupt after REA already received
+    // it directly. Keep both guards installed until provider cleanup has settled.
+    process.on("SIGINT", cancel);
+    process.on("SIGTERM", cancel);
     try {
         return await operation(controller.signal);
     }
     finally {
         process.off("SIGINT", cancel);
+        process.off("SIGTERM", cancel);
     }
 };
 const prepareSnapshot = async (options) => {
@@ -251,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

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

package/dist/application/DirectAnalysisStatus.js

@@ -1,10 +1,10 @@
-import { parseConfig } from "../config.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 import { jsonObjectSchema } from "../domain/jsonValue.js";
 import { createServerIdentity } from "../serverIdentity.js";
 import { silentLogger } from "../logger.js";
-const runSessionStatus = async (dependencies, logger = silentLogger, environment = process.env) => {
-    const config = parseConfig(environment);
+/** 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) };
     const session = dependencies.createBinarySession(config.value, logger);
@@ -20,7 +20,3 @@ const runSessionStatus = async (dependencies, logger = silentLogger, environment
         await session.close();
     }
 };
-/** List binary-session provider candidates and auxiliary operation availability. */
-export const runProviderStatus = (dependencies, logger = silentLogger, environment = process.env) => runSessionStatus(dependencies, logger, environment);
-/** List binary-session operation descriptors; this is not the full MCP catalog. */
-export const runCapabilityStatus = (dependencies, logger = silentLogger, environment = process.env) => runSessionStatus(dependencies, logger, environment);