rea-agents 6.2.0 → 6.3.0

package/README.md

@@ -11,7 +11,7 @@
 [![npm version](https://img.shields.io/npm/v/rea-agents?style=flat-square&color=cb3837)](https://www.npmjs.com/package/rea-agents)
 [![CI](https://img.shields.io/github/actions/workflow/status/morluto/rea/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/morluto/rea/actions/workflows/ci.yml)
 [![MCP tool catalog](https://img.shields.io/badge/MCP-tool_catalog-5c4ee5?style=flat-square)](docs/mcp-contracts.md#generated-catalog)
-[![Node.js 22+](https://img.shields.io/badge/Node.js-22.19%2B-339933?style=flat-square&logo=nodedotjs&logoColor=white)](https://nodejs.org/)
+[![Node.js requirements](https://img.shields.io/badge/Node.js-requirements-339933?style=flat-square&logo=nodedotjs&logoColor=white)](#what-you-can-analyze)
 [![skills.sh](https://skills.sh/b/morluto/rea?style=flat-square)](https://skills.sh/morluto/rea/reverse-engineer-anything)
 [![MIT license](https://img.shields.io/badge/license-MIT-f4c430?style=flat-square)](LICENSE)
 [![Discord](https://img.shields.io/discord/1556595354999332884?logo=discord&logoColor=white&label=Discord&color=5865F2)](https://discord.gg/GkcryMnJDM)
@@ -28,7 +28,7 @@
 
 <img src="docs/assets/rea-hopper-analysis.png" alt="REA launching its analysis bridge inside Hopper while inspecting a native binary" width="1200" />
 
-<br />
+<br /><br />
 
 <table aria-label="REA community">
 <tr>
@@ -52,7 +52,7 @@ See a feature in an app that you want in your own product? Ask your agent to inv
 
 REA connects your agent to tools for inspecting native binaries, JavaScript and Electron apps, .NET assemblies, and websites. You can also use the same tools from your terminal. Analysis runs locally, and results include the evidence and limitations behind each conclusion.
 
-Setup registers REA with your agent and installs matching workflow instructions. Native analysis can use an existing Hopper or Ghidra installation; setup can optionally install Hopper with approval. Static JavaScript analysis needs neither engine.
+Setup registers REA with your agent and installs matching workflow instructions. Native analysis can use an existing Hopper, Ghidra, or IDA installation; setup can optionally install Hopper with approval. Static JavaScript analysis needs no native analysis engine.
 
 > **[Visit the REA website](https://rea.tools/)** for setup instructions, illustrated guides, and real case studies.
 
@@ -156,7 +156,7 @@ Additional tools and host support depend on the target:
 | JavaScript / Electron  | Modules, imports, source maps, routes, IPC and native add-on relationships           | Node.js and npm; [application analysis](https://rea.tools/guides/javascript/)                                                         |
 | Websites               | Page structure, scripts, network observations and requested screenshots              | A Chrome-family browser; [browser analysis](https://rea.tools/guides/browser/)                                                        |
 | Saved network captures | Requests, responses, exposed payloads and source locations                           | HAR; mitmdump on Linux for native mitmproxy captures; [capture guide](docs/web-network-captures.md)                                   |
-| .NET assemblies        | Metadata, CIL instructions, declared native dependencies and build comparisons       | Static inspection; [managed-code guide](docs/managed-code-analysis.md)                                                                |
+| .NET assemblies        | Metadata, CIL instructions, declared native dependencies and build comparisons       | None (static only); [managed-code guide](docs/managed-code-analysis.md)                                                               |
 | Android APKs           | Manifest declarations, classes, decompiled methods and references                    | Headless JADX and a full JDK on Linux/macOS/Windows x64; [Android guide](docs/android-analysis.md)                                    |
 | Firmware               | Regions, extraction results and native-analysis handoffs                             | Binwalk / Unblob on Linux; [firmware guide](docs/firmware-analysis.md)                                                                |
 | Packages and resources | File inventories, digests, plists, Apple bundle anatomy and extracted resources      | [Artifact and JavaScript guide](docs/javascript-artifact-reconstruction.md), [Apple applications](docs/apple-application-analysis.md) |
@@ -181,6 +181,8 @@ for features added since the latest npm release.
 
 ## Showcases
 
+[![Illustrations of the DX-Ball sound-pan, Notion clipboard-bridge, and TH04 bullet-ring showcases](docs/assets/rea-showcases.png)](https://rea.tools/showcase/)
+
 ### DX-Ball: reconstruct a sound-pan calculation
 
 Follow a sound call into its position-to-pan helper, inspect the instructions,
@@ -243,7 +245,7 @@ ask you to choose demo mode or activate your license. See
 <details>
 <summary><strong>What does installing the skill from skills.sh do?</strong></summary>
 
-The skill supplies investigation instructions for your agent. Use `rea setup`
+The skill supplies investigation instructions for your agent. Use `npx rea-agents setup`
 to register REA's MCP server and install the matching instructions, then restart
 your agent. See [skill-only installation](docs/installation.md#skill-only-installation).
 
@@ -303,23 +305,9 @@ For exact options, prerequisites and result contracts:
 
 Report vulnerabilities through [SECURITY.md](SECURITY.md).
 
-## Contributing
-
-We'd love your help with REA! [Open an issue](https://github.com/morluto/rea/issues) to
-report a bug or suggest a feature, or [send a pull request](https://github.com/morluto/rea/pulls)
-to improve the code or docs.
-
-See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and checks,
-[testing](docs/testing.md) for verification lanes, and the
-[architecture map](docs/architecture.mermaid) for the project structure.
-
-## Project links
-
-[Website](https://rea.tools/) · [npm](https://www.npmjs.com/package/rea-agents) · [skills.sh](https://skills.sh/morluto/rea/reverse-engineer-anything) · [Issues](https://github.com/morluto/rea/issues) · [Security](SECURITY.md)
-
 ## Star history
 
-🎉 **30,000 GitHub stars — thank you!**
+🎉 **40,000 GitHub stars — thank you!**
 
 Thanks to everyone using REA, reporting bugs, requesting features, testing builds, and contributing fixes.
 
@@ -337,6 +325,16 @@ REA provides tools for lawful reverse-engineering research, analysis, and recons
 
 REA is an open-source software project. We have not issued or endorsed any cryptocurrency or token. Tokens using the REA name are not affiliated with the project.
 
+## Contributing
+
+We'd love your help with REA! [Open an issue](https://github.com/morluto/rea/issues) to
+report a bug or suggest a feature, or [send a pull request](https://github.com/morluto/rea/pulls)
+to improve the code or docs.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and checks,
+[testing](docs/testing.md) for verification lanes, and the
+[architecture map](docs/architecture.mermaid) for the project structure.
+
 ## License
 
 [MIT](LICENSE)

package/bridge/hopper_bridge.py

@@ -716,6 +716,8 @@ def _analyze_function(document, params):
         "referenced_strings": referenced_strings,
         "referenced_names": referenced_names,
         "basic_blocks": blocks,
+        "native_api": None,
+        "native_value_flow": None,
         "limitations": [
             "Native CallReference classifications are observed where available; detailed reference flags remain unknown.",
             "Hopper's public Python API does not expose equivalent external or thunk classification in this dossier.",

package/dist/android/JadxProvider.js

@@ -71,7 +71,7 @@ const cleanup = async (resources) => {
     }
     catch (cause) {
         // Retain an uncertain workspace until the caller can resolve process ownership.
-        return err(new ProviderCleanupError("jadx", [
+        const error = new ProviderCleanupError("jadx", [
             session?.transport.runId ?? "unknown",
             ...(root === undefined ? [] : [root.path]),
         ], {
@@ -80,7 +80,10 @@ const cleanup = async (resources) => {
             provider_cleanup: cause instanceof ProviderCleanupError
                 ? (cause.diagnostics ?? null)
                 : null,
-        }, { cause: previousError ?? cause }));
+        }, { cause: previousError ?? cause });
+        if (previousError?.partialObservation !== undefined)
+            error.retainPartialObservation(previousError.partialObservation);
+        return err(error);
     }
     try {
         await root?.close();
@@ -287,6 +290,9 @@ export class JadxProvider {
                 signal: options?.signal,
                 session,
             });
+            const partialObservation = session?.partialObservation();
+            if (partialObservation !== undefined)
+                previousError.retainPartialObservation(partialObservation);
             // Admission can fail before selecting an existing session for execution.
             root ??= this.#retained?.root;
             session ??= this.#retained?.session;

package/dist/android/JadxSession.js

@@ -13,12 +13,28 @@ export class JadxSession {
     #client = new Client({ name: "rea-android-adapter", version: "1" });
     #loaded;
     #connected = false;
+    #partialContext;
+    #observedCalls = [];
+    #serverName = null;
+    #serverVersion = null;
+    #engineVersion = null;
     constructor(options, launcher) {
         this.transport = new JadxMcpTransport(options, launcher);
     }
     /** Analyze one admitted immutable APK, checking producer identity and selectors. */
     async execute(context) {
         const { request, target, snapshot, jarHash, signal } = context;
+        this.#partialContext = {
+            operation: request.operation,
+            selectedPath: request.input.path,
+            target,
+            jarHash,
+            bridgeHash: context.bridgeHash,
+        };
+        this.#observedCalls = [];
+        this.#serverName = null;
+        this.#serverVersion = null;
+        this.#engineVersion = null;
         const abort = () => {
             void this.transport.close().catch(() => undefined);
         };
@@ -26,17 +42,19 @@ export class JadxSession {
         try {
             signal.throwIfAborted();
             this.transport.beginOperation();
-            const raw = [];
             if (!this.#connected) {
                 await this.#client.connect(this.transport, { timeout: 30_000 });
                 this.#connected = true;
             }
             const server = this.#client.getServerVersion();
+            this.#serverName = server?.name ?? null;
+            this.#serverVersion = server?.version ?? null;
             if (server?.name !== JADX_BRIDGE_IDENTITY.name ||
                 server.version !== JADX_BRIDGE_IDENTITY.version)
                 throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Expected ${JADX_BRIDGE_IDENTITY.name} ${JADX_BRIDGE_IDENTITY.version}; server reported ${server?.name ?? "unknown"} ${server?.version ?? "unknown"}.`);
-            const tools = this.#tools(request, target, signal, raw);
+            const tools = this.#tools(request, target, signal);
             const runtime = jadxRuntimeSchema.parse(await tools.json("rea_jvm_status", {}));
+            this.#engineVersion = runtime.engine_reported_version;
             if (runtime.engine_reported_version !== JADX_RELEASE.version)
                 throw new AnalysisCapabilityUnavailableError("jadx", request.operation, `Expected engine ${JADX_RELEASE.version}; JAR reported ${runtime.engine_reported_version}.`);
             const loaded = this.#loaded ??
@@ -63,7 +81,7 @@ export class JadxSession {
                     bridge_sha256: context.bridgeHash,
                     jar_sha256: jarHash,
                     loaded,
-                    calls: raw,
+                    calls: this.#observedCalls,
                 },
                 subject: target,
                 limitations: JADX_LIMITATIONS,
@@ -76,6 +94,32 @@ export class JadxSession {
             signal.removeEventListener("abort", abort);
         }
     }
+    /** Facts and upstream replies retained if a later request step fails. */
+    partialObservation() {
+        const context = this.#partialContext;
+        if (context === undefined)
+            return undefined;
+        return {
+            provider_id: "jadx",
+            operation: context.operation,
+            target: {
+                selected_path: context.selectedPath,
+                path: context.target.path,
+                sha256: context.target.sha256,
+                format: "apk",
+            },
+            provider_facts: {
+                jar_sha256: context.jarHash,
+                bridge_sha256: context.bridgeHash,
+                bridge_name: JADX_BRIDGE_IDENTITY.name,
+                bridge_version: JADX_BRIDGE_IDENTITY.version,
+                server_name: this.#serverName,
+                server_version: this.#serverVersion,
+                engine_version: this.#engineVersion,
+            },
+            calls: this.#observedCalls,
+        };
+    }
     /** Whether the selected Java runtime established the REA bridge protocol. */
     initialized() {
         return this.#connected;
@@ -89,16 +133,14 @@ export class JadxSession {
             await this.transport.close();
         }
     }
-    #tools(request, target, signal, raw) {
+    #tools(request, target, signal) {
         const call = async (name, input) => {
             signal.throwIfAborted();
             const response = await this.#client.callTool({ name, arguments: input }, { timeout: 120_000, signal });
+            const observedResponse = jsonValueSchema.parse(response);
+            const call = { operation: name, input, response: observedResponse };
+            this.#observedCalls.push(call);
             const envelope = parseJadxEnvelope(response, request.operation);
-            raw.push({
-                operation: name,
-                input,
-                response: jsonValueSchema.parse(response),
-            });
             if (envelope.failed) {
                 if (envelope.text.startsWith("{")) {
                     const failure = jadxInputFailureSchema.safeParse(parseJadxJson(envelope.text, request.operation));

package/dist/application/BinaryTargetResolver.js

@@ -1,8 +1,10 @@
 import { constants } from "node:fs";
 import { createHash } from "node:crypto";
-import { access, open, realpath, stat, } from "node:fs/promises";
+import { access, lstat, realpath, stat, } from "node:fs/promises";
 import { extname, isAbsolute, resolve } from "node:path";
 import { BinaryTargetError } from "../domain/configurationErrors.js";
+import { openRegularFile, sameRegularFileState, } from "../filesystem/RegularFile.js";
+import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
 import { err, ok } from "../domain/result.js";
 import { resolveAppBundleExecutable, } from "./AppBundleExecutable.js";
 import { validateDosComLength, } from "../domain/dosCom.js";
@@ -14,30 +16,41 @@ import { parseExecutableHeader, parsePeRecord, } from "../domain/binaryTarget.js
  * FAT Mach-O inputs select only a host-compatible architecture so setup remains
  * non-interactive; unsupported or ambiguous inputs are returned as typed errors.
  */
-export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitecture = process.arch, targetKind, formatHint) => {
+export const parseBinaryTarget = async (input, options = {}) => {
+    const cwd = options.cwd ?? process.cwd();
+    const hostArchitecture = options.hostArchitecture ?? process.arch;
+    const { targetKind, formatHint, signal } = options;
     const candidate = isAbsolute(input) ? input : resolve(cwd, input);
     try {
+        throwIfTargetResolutionCancelled(signal);
         await access(candidate, constants.R_OK);
+        throwIfTargetResolutionCancelled(signal);
         const canonical = await realpath(candidate);
+        throwIfTargetResolutionCancelled(signal);
         const resolved = await resolveAppBundle(canonical);
+        throwIfTargetResolutionCancelled(signal);
         if (!resolved.ok)
             return err(resolved.error);
         const { executable: path, infoPlist } = resolved.value;
         const bundle = infoPlist === undefined ? {} : { bundleInfoPlist: infoPlist };
-        const handle = await open(path, "r");
+        const handle = await openRegularFile(path, {
+            symlinks: "reject",
+            signal,
+        });
         try {
-            if (!(await handle.stat()).isFile())
-                return err(new BinaryTargetError(path, "target is not a regular file"));
+            throwIfTargetResolutionCancelled(signal);
+            const metadata = await handle.stat();
+            throwIfTargetResolutionCancelled(signal);
             if (formatHint === "dos-com") {
                 if (targetKind !== undefined && targetKind !== "executable")
                     return err(new BinaryTargetError(path, "DOS COM format requires an executable target kind"));
-                const length = validateDosComLength((await handle.stat()).size);
+                const length = validateDosComLength(metadata.size);
                 if (!length.ok)
                     return err(new BinaryTargetError(path, length.error));
                 return ok({
                     path,
                     sourcePath: canonical,
-                    sha256: await sha256Handle(handle),
+                    sha256: await sha256Handle(handle, path, metadata, signal),
                     kind: "executable",
                     format: "dos-com",
                     architecture: "x86",
@@ -49,29 +62,29 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
                 return ok({
                     path,
                     sourcePath: process.platform === "win32" ? candidate : canonical,
-                    sha256: await sha256Handle(handle),
+                    sha256: await sha256Handle(handle, path, metadata, signal),
                     kind: "database",
                     format: "analysis-database",
                 });
-            const artifactFormat = await detectArtifactFormat(path, handle);
+            const artifactFormat = await detectArtifactFormat(path, handle, signal);
             if (artifactFormat !== undefined) {
                 const identity = {
                     path,
                     sourcePath: process.platform === "win32" ? candidate : canonical,
-                    sha256: await sha256Handle(handle),
+                    sha256: await sha256Handle(handle, path, metadata, signal),
                 };
                 return isArchiveFormat(artifactFormat)
                     ? ok({ ...identity, kind: "archive", format: artifactFormat })
                     : ok({ ...identity, kind: "artifact", format: artifactFormat });
             }
-            const detected = await readExecutableMetadata(handle, hostArchitecture);
+            const detected = await readExecutableMetadata(handle, hostArchitecture, signal);
             if (!detected.ok)
                 return err(new BinaryTargetError(path, detected.error));
             return ok({
                 path,
                 sourcePath: process.platform === "win32" ? candidate : canonical,
                 ...bundle,
-                sha256: await sha256Handle(handle),
+                sha256: await sha256Handle(handle, path, metadata, signal),
                 kind: "executable",
                 ...detected.value,
             });
@@ -81,6 +94,10 @@ export const parseBinaryTarget = async (input, cwd = process.cwd(), hostArchitec
         }
     }
     catch (cause) {
+        if (cause instanceof AnalysisCancelledError)
+            return err(cause);
+        if (cause instanceof BinaryTargetError)
+            return err(cause);
         if (!(cause instanceof Error))
             throw cause;
         const code = filesystemErrorCode(cause);
@@ -103,14 +120,24 @@ const targetFailureReason = (code, detail) => {
             return `permission denied while reading target: ${detail}`;
         case "EISDIR":
             return `target is a directory, not a readable file: ${detail}`;
+        case "ENOTFILE":
+            return "target is not a regular file";
+        case "ELOOP":
+            return `target changed while being opened: ${detail}`;
         default:
             return `target could not be read (${code}): ${detail}`;
     }
 };
-const detectArtifactFormat = async (path, handle) => {
+const throwIfTargetResolutionCancelled = (signal) => {
+    if (signal?.aborted === true)
+        throw new AnalysisCancelledError("resolve_binary_target");
+};
+const detectArtifactFormat = async (path, handle, signal) => {
+    throwIfTargetResolutionCancelled(signal);
     const lower = path.toLowerCase();
     const magic = Buffer.alloc(8);
     const observed = await handle.read(magic, 0, magic.length, 0);
+    throwIfTargetResolutionCancelled(signal);
     if (hasZipSignature(magic.subarray(0, observed.bytesRead))) {
         return zipPackageFormatForPath(lower) ?? "zip";
     }
@@ -122,10 +149,13 @@ const detectArtifactFormat = async (path, handle) => {
         magic.subarray(0, 4).toString("ascii") === "xar!")
         return "pkg";
     if (lower.endsWith(".dmg")) {
+        throwIfTargetResolutionCancelled(signal);
         const size = (await handle.stat()).size;
+        throwIfTargetResolutionCancelled(signal);
         if (size >= 512) {
             const trailer = Buffer.alloc(4);
             const read = await handle.read(trailer, 0, trailer.length, size - 512);
+            throwIfTargetResolutionCancelled(signal);
             if (read.bytesRead === 4 && trailer.toString("ascii") === "koly")
                 return "dmg";
         }
@@ -142,17 +172,25 @@ const namedArtifactFormat = (lowerPath) => {
     return /\.(?:m?js|cjs)$/u.test(lowerPath) ? "javascript" : undefined;
 };
 const isArchiveFormat = (format) => ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(format);
-const sha256Handle = async (handle) => {
+const sha256Handle = async (handle, path, initial, signal) => {
     const hash = createHash("sha256");
     const chunk = Buffer.allocUnsafe(64 * 1024);
     let position = 0;
     while (true) {
+        throwIfTargetResolutionCancelled(signal);
         const observed = await handle.read(chunk, 0, chunk.length, position);
+        throwIfTargetResolutionCancelled(signal);
         if (observed.bytesRead === 0)
             break;
         hash.update(chunk.subarray(0, observed.bytesRead));
         position += observed.bytesRead;
     }
+    throwIfTargetResolutionCancelled(signal);
+    const [opened, currentPath] = await Promise.all([handle.stat(), lstat(path)]);
+    if (!sameRegularFileState(initial, opened) ||
+        !sameRegularFileState(initial, currentPath) ||
+        position !== initial.size)
+        throw new BinaryTargetError(path, "target changed while being read");
     return hash.digest("hex");
 };
 const resolveAppBundle = async (path) => {
@@ -165,19 +203,22 @@ const resolveAppBundle = async (path) => {
         }));
     return resolveAppBundleExecutable(path);
 };
-const readExecutableMetadata = async (handle, hostArchitecture) => {
+const readExecutableMetadata = async (handle, hostArchitecture, signal) => {
+    throwIfTargetResolutionCancelled(signal);
     const prefix = Buffer.alloc(4096);
     const prefixRead = await handle.read(prefix, 0, prefix.length, 0);
+    throwIfTargetResolutionCancelled(signal);
     const bytes = prefix.subarray(0, prefixRead.bytesRead);
     // Header commitments such as Mach-O load commands and FAT slices are
     // checked against the whole file, not the probed prefix.
     const fileSize = (await handle.stat()).size;
+    throwIfTargetResolutionCancelled(signal);
     if (bytes.length >= 2 && bytes[0] === 0x4d && bytes[1] === 0x5a) {
         const offset = mzWindowsHeaderOffset(bytes);
         if (offset !== null) {
             if (offset < 64)
                 return err("invalid Windows new-header offset in MZ image");
-            return readPeMetadata(handle, offset);
+            return readPeMetadata(handle, offset, signal);
         }
         // MZ relocation records may extend past the initial probe; their format
         // bounds are at most 65535 records inside a 65535-paragraph header.
@@ -190,6 +231,7 @@ const readExecutableMetadata = async (handle, hostArchitecture) => {
             tableEnd <= fileSize) {
             const table = Buffer.alloc(tableEnd);
             const observed = await handle.read(table, 0, table.length, 0);
+            throwIfTargetResolutionCancelled(signal);
             return parseExecutableHeader(table.subarray(0, observed.bytesRead), hostArchitecture, fileSize);
         }
         return parseExecutableHeader(bytes, hostArchitecture, fileSize);
@@ -203,15 +245,18 @@ const readExecutableMetadata = async (handle, hostArchitecture) => {
             if (count <= 128 && required > bytes.length) {
                 const header = Buffer.alloc(required);
                 const headerRead = await handle.read(header, 0, header.length, 0);
+                throwIfTargetResolutionCancelled(signal);
                 return parseExecutableHeader(header.subarray(0, headerRead.bytesRead), hostArchitecture, fileSize);
             }
         }
     }
     return parseExecutableHeader(bytes, hostArchitecture, fileSize);
 };
-const readPeMetadata = async (handle, offset) => {
+const readPeMetadata = async (handle, offset, signal) => {
+    throwIfTargetResolutionCancelled(signal);
     const fileHeader = Buffer.alloc(24);
     const fileHeaderRead = await handle.read(fileHeader, 0, fileHeader.length, offset);
+    throwIfTargetResolutionCancelled(signal);
     if (fileHeaderRead.bytesRead !== fileHeader.length)
         return err("invalid or truncated PE header");
     const signature = fileHeader.toString("ascii", 0, 2);
@@ -222,6 +267,7 @@ const readPeMetadata = async (handle, offset) => {
         return err("invalid PE optional header size");
     const record = Buffer.alloc(24 + optionalHeaderSize);
     const recordRead = await handle.read(record, 0, record.length, offset);
+    throwIfTargetResolutionCancelled(signal);
     return recordRead.bytesRead === record.length
         ? parsePeRecord(record)
         : err("invalid or truncated PE header");

package/dist/application/BrowserScenarioEvidence.js

@@ -1,9 +1,9 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
 import { createEvidence, } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
 const browserScenarioParameters = (scenario) => ({
     ...jsonObjectSchema.parse(scenario),
-    scenario_sha256: canonicalDigest(scenario, "Browser scenario"),
+    scenario_sha256: digestCanonicalValue(scenario, "Browser scenario"),
 });
 /** Create Evidence without retaining resolved scenario secret values. */
 export const createBrowserScenarioEvidence = (scenario, capture, provider) => createEvidence(undefined, provider, {

package/dist/application/ClientConfigurationDocument.js

@@ -858,6 +858,33 @@ const tomlServerEntry = (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 = tomlServerEntry(document, PRODUCT_IDENTITY.mcpServerKey);
@@ -1051,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.";