rea-agents 4.0.1 → 5.0.0

package/dist/application/Setup.js

@@ -1,47 +1,6 @@
-import { access } from "node:fs/promises";
-import { homedir } from "node:os";
-import { resolve } from "node:path";
-import { PRODUCT_IDENTITY } from "../identity.js";
-import { supportsNodeVersion } from "../domain/runtimeVersion.js";
-import { runDoctor, systemDoctorHost, } from "./Doctor.js";
-import { installLinuxHopper, readLinuxDistribution, } from "./LinuxHopper.js";
-import { installMacHopper } from "./MacHopper.js";
 import { configureDetectedClients } from "./SetupClients.js";
-import { supportedClients } from "./SupportedClients.js";
-import { canonicalSkillNeedsInstall, installCanonicalSkill, } from "./SetupSkill.js";
 import { discoverSetupState, planSetupActions } from "./SetupPlan.js";
-import { clientConfigurationAligned, configureClientConfiguration, configureJsonClient, configureTomlClient, inspectClientConfiguration, } from "./SetupClientConfiguration.js";
-export { configureJsonClient, configureTomlClient };
-import { setupInstallFailure, } from "./SetupInstallFailure.js";
-import { providerRegistrationEnvironment } from "./SetupRegistrationEnvironment.js";
-export { canonicalSkillNeedsInstall, installCanonicalSkill };
-/** Resolve the executable and arguments used in a managed MCP registration. */
-export const setupRegistrationCommand = (platform, useNpmRunner = process.env.npm_command === "exec") => useNpmRunner
-    ? PRODUCT_IDENTITY.mcpCommand.split(" ")
-    : platform === "win32"
-        ? [
-            process.execPath,
-            resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary),
-            "mcp",
-        ]
-        : [resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary), "mcp"];
-/** Whether the requested setup actions still need approval or human repair. */
-export const isSetupFailure = (result) => {
-    const status = result.status;
-    switch (status) {
-        case "planned":
-        case "cancelled":
-        case "ready":
-            return false;
-        case "needs_confirmation":
-        case "needs_human":
-            return true;
-        default: {
-            const exhaustive = status;
-            throw new TypeError(`Unhandled setup result status: ${String(exhaustive)}`);
-        }
-    }
-};
+import { filterClientsNeedingConfigure, hostRemediation, initialProviderEnvironment, setupRegistrationCommand, systemSetupHost, } from "./SetupHost.js";
 /** Discover, approve, and apply setup actions idempotently. */
 export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     const appliedActions = [];
@@ -53,14 +12,22 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     const unsupported = await hostRemediation(host, false);
     if (unsupported !== undefined)
         return fail(unsupported);
-    let hopperPath = await host.hopperPath();
-    let providerEnvironment = await initialProviderEnvironment(host, hopperPath);
+    const initialState = await host.initialSetupState?.(options.readinessScope);
+    let hopperPath = initialState === undefined
+        ? await host.hopperPath()
+        : initialState.hopperPath;
+    let providerEnvironment = initialState === undefined
+        ? await initialProviderEnvironment(host, hopperPath)
+        : initialState.providerEnvironment;
     const discovery = await discoverSetupState({
         host,
         providerEnvironment,
         forceHopperInstall: options.installHopper,
         proposeHopper: options.proposeHopper ?? (confirm !== undefined && !options.structured),
         doctorScope: options.readinessScope,
+        ...(initialState === undefined
+            ? {}
+            : { initialDoctor: initialState.doctor }),
     });
     clientStates = discovery.clientStates;
     const clientSelectionAllowed = options.clientIds === undefined &&
@@ -310,14 +277,6 @@ const setupFailure = async (remediation, [host, plannedActions, appliedActions,
     };
 };
 const emitProgress = (options, event) => options.onProgress?.(event);
-const filterClientsNeedingConfigure = async (host, detectedClients, providerEnvironment, command) => {
-    const needs = await Promise.all(detectedClients.map((client) => host.clientNeedsConfigure(client, providerEnvironment, command)));
-    return detectedClients.filter((_, index) => needs[index]);
-};
-const initialProviderEnvironment = async (host, hopperPath) => ({
-    ...(await host.providerEnvironment?.()),
-    ...(hopperPath === undefined ? {} : { HOPPER_LAUNCHER_PATH: hopperPath }),
-});
 const finalSetupRemediation = (platform, installedHopper, healthy, hopperPath) => {
     if (platform === "darwin" && installedHopper)
         return "Open Hopper, choose its demo mode or activate a license, then rerun rea doctor --json.";
@@ -371,81 +330,3 @@ const summarizeDoctor = (report) => ({
             },
         }),
 });
-const hostRemediation = async (host, installHopper) => {
-    if (!supportsNodeVersion(host.nodeVersion))
-        return "Install Node.js 22.19+ or 24.11+ and rerun setup.";
-    if (!installHopper)
-        return undefined;
-    if (host.platform !== "darwin" && host.platform !== "linux")
-        return "REA supports Hopper on macOS and selected 64-bit Linux distributions.";
-    if (host.platform === "darwin") {
-        const version = await host.macosVersion();
-        return version === undefined || major(version) < 12
-            ? "Upgrade to macOS 12 or newer."
-            : undefined;
-    }
-    if ((await host.linuxDistribution())?.supported === true)
-        return undefined;
-    return "Automated Hopper setup supports Ubuntu 24.04+, Fedora 41+, and 64-bit Arch Linux; configure an existing supported provider instead.";
-};
-/** Production setup effects for Hopper, agent configuration, and the canonical skill directory. */
-export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
-    const platform = doctorHost.platform;
-    return {
-        platform,
-        nodeVersion: process.versions.node,
-        macosVersion: () => doctorHost.macosVersion(),
-        linuxDistribution: readLinuxDistribution,
-        hopperPath: async () => (await runDoctor(undefined, doctorHost)).hopperPath,
-        providerEnvironment: async () => {
-            const diagnosis = await runDoctor(undefined, doctorHost);
-            return {
-                ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
-                ...(diagnosis.hopperPath === undefined
-                    ? {}
-                    : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),
-            };
-        },
-        installHopper: async (replaceExisting) => {
-            const result = platform === "linux"
-                ? await installLinuxHopper()
-                : await installMacHopper({ replaceExisting });
-            if (result.status === "installed")
-                return result;
-            return setupInstallFailure(result.reason);
-        },
-        detectedClients: () => detectClients(homedir()),
-        supportedClients: () => Promise.resolve(supportedClients(homedir())),
-        configureClient: (client, providerEnvironment, command) => client.format === "unsupported"
-            ? Promise.resolve({ status: "skipped" })
-            : configureClientConfiguration(client, providerEnvironment, command),
-        clientNeedsConfigure: (client, providerEnvironment, command) => clientConfigurationAligned(client, providerEnvironment, command).then((aligned) => !aligned),
-        inspectClientConfiguration: inspectClientConfiguration,
-        skillNeedsInstall: () => canonicalSkillNeedsInstall(homedir()),
-        installSkill: () => installCanonicalSkill(homedir()),
-        doctor: (scope) => runDoctor(undefined, doctorHost, scope),
-    };
-};
-/** Detect supported agents from their config files or stable installation markers. */
-export const detectClients = async (home) => {
-    const detected = [];
-    for (const candidate of supportedClients(home)) {
-        const [hasConfig, hasMarker] = await Promise.all([
-            exists(candidate.configPath),
-            candidate.markerPath === undefined ? false : exists(candidate.markerPath),
-        ]);
-        if (hasConfig || hasMarker)
-            detected.push(candidate);
-    }
-    return detected;
-};
-const major = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
-const exists = async (path) => {
-    try {
-        await access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};

package/dist/application/SetupClientConfiguration.js

@@ -1,4 +1,4 @@
-import { clientRegistrationEntry, clientConfigurationValuesEqual, parseClientConfiguration, serializeClientConfiguration, } from "./ClientConfigurationDocument.js";
+import { clientRegistrationEntry, clientConfigurationValuesEqual, clientServerPath, legacyClientServerPath, 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";
@@ -38,39 +38,47 @@ const configureClientDocument = async (client, environment, command, format) =>
     try {
         parsed = parseClientConfiguration(original ?? (format === "toml" ? "" : "{}"), format);
     }
-    catch {
+    catch (cause) {
+        // Malformed existing configuration fails the readback gate.
+        void cause;
         return { status: "failed", reason: "readback" };
     }
-    const { document, servers, serversKey } = parsed;
-    const desired = clientConfigurationDesired(client, environment, command, format);
-    if (clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
+    const desired = clientConfigurationDesired(client, environment, command, parsed.dialect);
+    if (registrationCurrent(parsed, desired))
         return { status: "unchanged" };
     const backupPath = original === undefined ? undefined : `${client.configPath}.rea.backup`;
     if (backupPath !== undefined &&
         !(await preserveConfigBackup(transactionPath, backupPath)))
         return { status: "failed", reason: "backup" };
-    document[serversKey] = {
-        ...servers,
-        [PRODUCT_IDENTITY.mcpServerKey]: desired,
-    };
+    // 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);
     try {
         await mkdir(dirname(client.configPath), { recursive: true });
-        await writeFileAtomic(transactionPath, serializeClientConfiguration(document, format, original, PRODUCT_IDENTITY.mcpServerKey), {
+        await writeFileAtomic(transactionPath, serializeClientConfiguration(document, format, original, [
+            clientServerPath(parsed, PRODUCT_IDENTITY.mcpServerKey),
+            ...(legacyPath === undefined ? [] : [legacyPath]),
+        ]), {
             encoding: "utf8",
             mode: 0o600,
         });
     }
-    catch {
+    catch (cause) {
+        // Write failure is reported by the status reason.
+        void cause;
         return { status: "failed", reason: "write" };
     }
     try {
         const readback = parseClientConfiguration(await readFile(transactionPath, "utf8"), format);
-        if (!clientConfigurationValuesEqual(readback.servers[PRODUCT_IDENTITY.mcpServerKey], desired)) {
+        if (!registrationCurrent(readback, desired)) {
             await restoreConfig(transactionPath, original);
             return { status: "failed", reason: "readback" };
         }
     }
-    catch {
+    catch (cause) {
+        // Readback failure restores the transaction before reporting.
+        void cause;
         await restoreConfig(transactionPath, original);
         return { status: "failed", reason: "readback" };
     }
@@ -81,13 +89,14 @@ const configureClientDocument = async (client, environment, command, format) =>
 };
 /** Determine whether an existing client configuration matches the desired registration. */
 export const clientConfigurationAligned = async (client, providerEnvironment, command) => {
-    const desired = clientConfigurationDesired(client, providerEnvironment, command, client.format);
     try {
         const original = await readFile(client.configPath, "utf8");
-        const { servers } = parseClientConfiguration(original, client.format);
-        return clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired);
+        const parsed = parseClientConfiguration(original, client.format);
+        return registrationCurrent(parsed, clientConfigurationDesired(client, providerEnvironment, command, parsed.dialect));
     }
-    catch {
+    catch (cause) {
+        // Unreadable configuration is treated as not aligned so setup repairs it.
+        void cause;
         return false;
     }
 };
@@ -113,13 +122,15 @@ export const inspectClientConfiguration = async (client, providerEnvironment, co
             remediation: "The configuration file could not be read. Check its permissions before rerunning setup.",
         };
     }
-    const desired = clientConfigurationDesired(client, providerEnvironment, command, client.format);
     try {
-        const { servers } = parseClientConfiguration(original, client.format);
-        if (clientConfigurationValuesEqual(servers[PRODUCT_IDENTITY.mcpServerKey], desired))
+        const parsed = parseClientConfiguration(original, client.format);
+        const desired = clientConfigurationDesired(client, providerEnvironment, command, parsed.dialect);
+        if (registrationCurrent(parsed, desired))
             return { status: "already_current" };
     }
-    catch {
+    catch (cause) {
+        // Malformed configuration is reported with the invalid remediation.
+        void cause;
         return {
             status: "invalid",
             remediation: "The existing configuration is malformed. Repair it before setup applies any other changes.",
@@ -147,10 +158,13 @@ const restoreConfig = async (path, original) => {
         else
             await writeFile(path, original, { encoding: "utf8", mode: 0o600 });
     }
-    catch {
+    catch (cause) {
         // The backup remains available for the remediation reported by setup.
+        void cause;
     }
 };
+/** Whether REA's entry matches and no conflicting legacy entry remains. */
+const registrationCurrent = (parsed, desired) => clientConfigurationValuesEqual(parsed.servers[PRODUCT_IDENTITY.mcpServerKey], desired) && !Object.hasOwn(parsed.legacyServers, 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

@@ -0,0 +1,126 @@
+import { access } from "node:fs/promises";
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { PRODUCT_IDENTITY } from "../identity.js";
+import { SUPPORTED_NODE_VERSION_PROSE, supportsNodeVersion, } from "../domain/runtimeVersion.js";
+import { runDoctor, systemDoctorHost } from "./Doctor.js";
+import { installLinuxHopper, readLinuxDistribution } from "./LinuxHopper.js";
+import { installMacHopper } from "./MacHopper.js";
+import { supportedClients } from "./SupportedClients.js";
+import { canonicalSkillNeedsInstall, installCanonicalSkill, } from "./SetupSkill.js";
+import { clientConfigurationAligned, configureClientConfiguration, inspectClientConfiguration, } from "./SetupClientConfiguration.js";
+import { setupInstallFailure } from "./SetupInstallFailure.js";
+import { providerRegistrationEnvironment } from "./SetupRegistrationEnvironment.js";
+/** Resolve the executable and arguments used in a managed MCP registration. */
+export const setupRegistrationCommand = (platform, useNpmRunner = process.env.npm_command === "exec") => useNpmRunner
+    ? PRODUCT_IDENTITY.mcpCommand.split(" ")
+    : platform === "win32"
+        ? [
+            process.execPath,
+            resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary),
+            "mcp",
+        ]
+        : [resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary), "mcp"];
+export const filterClientsNeedingConfigure = async (host, detectedClients, providerEnvironment, command) => {
+    const needs = await Promise.all(detectedClients.map((client) => host.clientNeedsConfigure(client, providerEnvironment, command)));
+    return detectedClients.filter((_, index) => needs[index]);
+};
+export const initialProviderEnvironment = async (host, hopperPath) => ({
+    ...(await host.providerEnvironment?.()),
+    ...(hopperPath === undefined ? {} : { HOPPER_LAUNCHER_PATH: hopperPath }),
+});
+export const hostRemediation = async (host, installHopper) => {
+    if (!supportsNodeVersion(host.nodeVersion))
+        return `Install ${SUPPORTED_NODE_VERSION_PROSE} and rerun setup.`;
+    if (!installHopper)
+        return undefined;
+    if (host.platform !== "darwin" && host.platform !== "linux")
+        return "REA supports Hopper on macOS and selected 64-bit Linux distributions.";
+    if (host.platform === "darwin") {
+        const version = await host.macosVersion();
+        return version === undefined || major(version) < 12
+            ? "Upgrade to macOS 12 or newer."
+            : undefined;
+    }
+    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.";
+};
+/** Production setup effects for Hopper, agent configuration, and the canonical skill directory. */
+export const systemSetupHost = (doctorHost = systemDoctorHost()) => {
+    const platform = doctorHost.platform;
+    return {
+        platform,
+        nodeVersion: process.versions.node,
+        macosVersion: () => doctorHost.macosVersion(),
+        linuxDistribution: readLinuxDistribution,
+        hopperPath: async () => (await runDoctor(undefined, doctorHost)).hopperPath,
+        initialSetupState: async (scope) => {
+            const diagnosis = await runDoctor(undefined, doctorHost, scope);
+            return {
+                ...(diagnosis.hopperPath === undefined
+                    ? {}
+                    : { hopperPath: diagnosis.hopperPath }),
+                providerEnvironment: {
+                    ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
+                    ...(diagnosis.hopperPath === undefined
+                        ? {}
+                        : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),
+                },
+                doctor: diagnosis,
+            };
+        },
+        providerEnvironment: async () => {
+            const diagnosis = await runDoctor(undefined, doctorHost);
+            return {
+                ...providerRegistrationEnvironment(diagnosis.providerInspections ?? []),
+                ...(diagnosis.hopperPath === undefined
+                    ? {}
+                    : { HOPPER_LAUNCHER_PATH: diagnosis.hopperPath }),
+            };
+        },
+        installHopper: async (replaceExisting) => {
+            const result = platform === "linux"
+                ? await installLinuxHopper()
+                : await installMacHopper({ replaceExisting });
+            if (result.status === "installed")
+                return result;
+            return setupInstallFailure(result.reason);
+        },
+        detectedClients: () => detectClients(homedir()),
+        supportedClients: () => Promise.resolve(supportedClients(homedir())),
+        configureClient: (client, providerEnvironment, command) => client.format === "unsupported"
+            ? Promise.resolve({ status: "skipped" })
+            : configureClientConfiguration(client, providerEnvironment, command),
+        clientNeedsConfigure: (client, providerEnvironment, command) => clientConfigurationAligned(client, providerEnvironment, command).then((aligned) => !aligned),
+        inspectClientConfiguration: inspectClientConfiguration,
+        skillNeedsInstall: () => canonicalSkillNeedsInstall(homedir()),
+        installSkill: () => installCanonicalSkill(homedir()),
+        doctor: (scope) => runDoctor(undefined, doctorHost, scope),
+    };
+};
+/** Detect supported agents from their config files or stable installation markers. */
+export const detectClients = async (home) => {
+    const detected = [];
+    for (const candidate of supportedClients(home)) {
+        const [hasConfig, hasMarker] = await Promise.all([
+            exists(candidate.configPath),
+            candidate.markerPath === undefined ? false : exists(candidate.markerPath),
+        ]);
+        if (hasConfig || hasMarker)
+            detected.push(candidate);
+    }
+    return detected;
+};
+const major = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
+const exists = async (path) => {
+    try {
+        await access(path);
+        return true;
+    }
+    catch (cause) {
+        // best-effort cleanup: optional host probing; absence means unavailable.
+        void cause;
+        return false;
+    }
+};

package/dist/application/SetupPlan.js

@@ -6,7 +6,7 @@ import { linuxHopperInstallDisclosure, } from "./LinuxHopper.js";
 import { macHopperInstallDisclosure } from "./MacHopper.js";
 /** Discover supported clients and current registrations without mutation. */
 export const discoverSetupState = async (input) => {
-    const initialDoctor = await input.host.doctor(input.doctorScope);
+    const initialDoctor = input.initialDoctor ?? (await input.host.doctor(input.doctorScope));
     const linuxHopperRepairNeeded = initialDoctor.checks.some(({ name, ok, detail }) => !ok &&
         (name === "hopper-demo-runtime" ||
             (name === "hopper-version" && detail === "/opt/hopper/bin/Hopper")));

package/dist/application/SetupRegistrationEnvironment.js

@@ -1,5 +1,4 @@
-/** Select exact non-secret settings published by available providers. */
+/** Preserve adapter-published settings independently of runtime readiness. */
 export const providerRegistrationEnvironment = (inspections) => Object.fromEntries(inspections
-    .filter(({ available }) => available)
     .flatMap(({ registrationEnvironment }) => Object.entries(registrationEnvironment))
     .sort(([left], [right]) => left.localeCompare(right)));

package/dist/application/SetupSkill.js

@@ -6,6 +6,7 @@ const SKILL_FILES = [
     "SKILL.md",
     "references/native-and-artifacts.md",
     "references/javascript-applications.md",
+    "references/android-applications.md",
     "references/runtime-observation.md",
     "references/evidence-workflows.md",
 ];
@@ -33,7 +34,9 @@ export const canonicalSkillNeedsInstall = async (home) => {
     try {
         return (await canonicalSkillFiles(home)).some(({ content, original }) => original !== content);
     }
-    catch {
+    catch (cause) {
+        // Unreadable skill state fails open to install so setup can repair it.
+        void cause;
         return true;
     }
 };
@@ -66,12 +69,15 @@ export const installCanonicalSkill = async (home) => {
                 throw new Error(`skill readback mismatch: ${destination}`);
         return "installed";
     }
-    catch {
+    catch (cause) {
+        // Install failure preserves the original error outcome; report cause inline.
+        void cause;
         try {
             await restoreSkillFiles(changed);
         }
-        catch {
+        catch (restoreCause) {
             // Per-file backups remain beside changed files for operator recovery.
+            void restoreCause;
         }
         return "failed";
     }

package/dist/application/SetupTypes.js

@@ -0,0 +1,17 @@
+/** Whether the requested setup actions still need approval or human repair. */
+export const isSetupFailure = (result) => {
+    const status = result.status;
+    switch (status) {
+        case "planned":
+        case "cancelled":
+        case "ready":
+            return false;
+        case "needs_confirmation":
+        case "needs_human":
+            return true;
+        default: {
+            const exhaustive = status;
+            throw new TypeError(`Unhandled setup result status: ${String(exhaustive)}`);
+        }
+    }
+};

package/dist/application/StoreFileLock.js

@@ -34,7 +34,10 @@ export const createStoreFileLock = async (path) => {
         }
         return {
             release: async () => {
-                await removeOwner(path, owner).catch(() => undefined);
+                await removeOwner(path, owner).catch((cause) => {
+                    // best-effort cleanup: lock release must not reject unhandled.
+                    void cause;
+                });
             },
         };
     }
@@ -68,7 +71,9 @@ export const removeStaleStoreFileLock = async (path) => {
         await removeOwner(path, owner);
         return true;
     }
-    catch {
+    catch (cause) {
+        // best-effort cleanup: stale lock probing; failure means the lock stands.
+        void cause;
         return false;
     }
 };

package/dist/application/SupportedClients.js

@@ -18,6 +18,7 @@ const claudeCodeConfigDirectory = ({ home, env }) => env.CLAUDE_CONFIG_DIR ?? ho
 const claudeCodeMarkerDirectory = ({ home, env }) => env.CLAUDE_CONFIG_DIR ?? join(home, ".claude");
 const codexDirectory = ({ home, env }) => env.CODEX_HOME ?? join(home, ".codex");
 const copilotDirectory = ({ home, env }) => env.COPILOT_HOME ?? join(home, ".copilot");
+const commandCodeDirectory = ({ home }) => join(home, ".commandcode");
 const opencodeDirectory = ({ home, env }) => join(env.XDG_CONFIG_HOME ?? join(home, ".config"), "opencode");
 const existingOpenCodeConfigPath = (context) => {
     if (context.env.OPENCODE_CONFIG !== undefined)
@@ -118,6 +119,13 @@ export const SUPPORTED_CLIENT_DEFINITIONS = [
         markerPath: copilotDirectory,
         format: "copilot_cli",
     },
+    {
+        name: "commandcode",
+        displayName: "Command Code",
+        configPath: (context) => join(commandCodeDirectory(context), "mcp.json"),
+        markerPath: commandCodeDirectory,
+        format: "commandcode",
+    },
     {
         name: "vscode",
         displayName: "VS Code",

package/dist/application/Uninstall.js

@@ -1,4 +1,4 @@
-import { parseClientConfiguration, serializeClientConfiguration, } from "./ClientConfigurationDocument.js";
+import { parseClientConfiguration, serializeClientConfiguration, clientServerPath, legacyClientServerPath, withClientServers, } from "./ClientConfigurationDocument.js";
 import { copyFile, lstat, readFile, realpath, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -76,46 +76,57 @@ const removeClient = async (client, fileSystem) => {
             ? item(client.name, "skipped", "Configuration does not exist.")
             : item(client.name, "failed", "Configuration could not be read. Check file permissions, then rerun uninstall.");
     }
-    let document;
-    let key;
-    let servers;
+    let parsed;
     try {
-        ({
-            document,
-            servers,
-            serversKey: key,
-        } = parseClientConfiguration(original, client.format));
+        parsed = parseClientConfiguration(original, client.format);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return item(client.name, "failed", `Configuration is not valid ${client.format === "toml" ? "TOML" : client.format === "opencode" ? "JSONC" : "JSON"} and was not changed. Repair it, then rerun uninstall.`);
     }
-    const registration = servers[PRODUCT_IDENTITY.mcpServerKey];
-    if (registration === undefined)
+    const name = PRODUCT_IDENTITY.mcpServerKey;
+    // Beside a native OpenCode V2 table, OpenCode also loads a V1 `mcp.rea`.
+    const legacyPath = legacyClientServerPath(parsed, name);
+    const hasNative = Object.hasOwn(parsed.servers, name);
+    if (!hasNative && legacyPath === undefined)
         return item(client.name, "skipped", "REA registration is absent.");
-    if (!isOwnedRegistration(registration, client))
+    const removeNative = hasNative && isOwnedRegistration(parsed.servers[name], client);
+    const removeLegacy = legacyPath !== undefined &&
+        isOwnedRegistration(parsed.legacyServers[name], client);
+    if (!removeNative && !removeLegacy)
         return item(client.name, "retained", "The rea-named registration is not REA-owned.");
-    const remaining = { ...servers };
-    delete remaining[PRODUCT_IDENTITY.mcpServerKey];
-    document[key] = remaining;
+    const remaining = { ...parsed.servers };
+    if (removeNative)
+        delete remaining[name];
+    const document = withClientServers(parsed, remaining, removeLegacy ? name : undefined);
+    const editedPaths = [
+        ...(removeNative ? [clientServerPath(parsed, name)] : []),
+        ...(removeLegacy ? [legacyPath] : []),
+    ];
     const backupPath = `${client.configPath}.rea.backup`;
     try {
         await fileSystem.copy(transactionPath, backupPath);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return item(client.name, "failed", "Configuration could not be backed up, so no change was made. Check file permissions, then rerun uninstall.");
     }
     try {
-        await fileSystem.writeText(transactionPath, serializeClientConfiguration(document, client.format, original, PRODUCT_IDENTITY.mcpServerKey));
+        await fileSystem.writeText(transactionPath, serializeClientConfiguration(document, client.format, original, editedPaths));
         const readback = parseClientConfiguration(await fileSystem.readText(transactionPath), client.format);
-        if (PRODUCT_IDENTITY.mcpServerKey in readback.servers)
+        if ((removeNative && Object.hasOwn(readback.servers, name)) ||
+            (removeLegacy && Object.hasOwn(readback.legacyServers, name)))
             throw new Error("registration readback mismatch");
         return item(client.name, "removed", `Removed registration from ${client.configPath}.`);
     }
-    catch {
+    catch (cause) {
+        // Update failure attempts a restore before reporting; cause is preserved below.
+        void cause;
         try {
             await fileSystem.writeText(transactionPath, original);
         }
-        catch {
+        catch (restoreCause) {
+            void restoreCause;
             return item(client.name, "failed", "Configuration could not be updated or restored. Restore its `.rea.backup` manually, then rerun uninstall.");
         }
         return item(client.name, "failed", "Configuration could not be updated. The original was restored and its `.rea.backup` was retained. Repair the configuration or restore the backup, then rerun uninstall.");

package/dist/application/UpdateMaintenance.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
 import { readClientRegistrationStatuses } from "./ClientRegistrationStatus.js";
-import { parseClientConfiguration } from "./ClientConfigurationDocument.js";
+import { effectiveClientServer, parseClientConfiguration, } from "./ClientConfigurationDocument.js";
 import { supportedClients } from "./SupportedClients.js";
 const setupPlanSchema = z.object({
     status: z.literal("planned"),
@@ -32,13 +32,13 @@ export const existingMaintenanceScope = async (home, entryPoint) => {
         const client = supported.find(({ name }) => name === registration.client);
         if (client === undefined)
             continue;
-        const { servers } = parseClientConfiguration(await readFile(client.configPath, "utf8"), client.format);
+        const parsed = parseClientConfiguration(await readFile(client.configPath, "utf8"), client.format);
         const enabled = z
             .object({
             enabled: z.boolean().optional(),
             disabled: z.boolean().optional(),
         })
-            .parse(servers[PRODUCT_IDENTITY.mcpServerKey]);
+            .parse(effectiveClientServer(parsed, PRODUCT_IDENTITY.mcpServerKey));
         if (enabled.enabled !== false && enabled.disabled !== true)
             clients.push(client.name);
     }