rea-agents 6.4.0 → 6.5.0

package/dist/application/Uninstall.js

@@ -1,5 +1,5 @@
-import { parseClientConfiguration, serializeClientConfiguration, clientServerPath, legacyClientServerPath, withClientServers, } from "./ClientConfigurationDocument.js";
-import { copyFile, lstat, realpath, rm } from "node:fs/promises";
+import { ClientConfigurationShapeError, parseClientConfiguration, serializeClientConfiguration, clientServerPath, legacyClientServerPath, withClientServers, } from "./ClientConfigurationDocument.js";
+import { copyFile, lstat, realpath, rm, rmdir } from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
 import { homeDirectoryFromEnvironment } from "../config/homeDirectory.js";
 import { join } from "node:path";
@@ -8,32 +8,24 @@ import { z } from "zod";
 import { PRODUCT_IDENTITY } from "../identity.js";
 import { isManagedSkillManifest, MANAGED_SKILL_FILES, readSkillFile, skillDestinations, } from "./SetupSkill.js";
 import { isOwnedClientRegistrationCommand } from "./ClientRegistrationIdentity.js";
+import { CURRENT_ENTRYPOINT_PATH } from "../process/CurrentEntrypointPath.js";
+import { dshDocument } from "./DshCordisPatch.js";
 import { resolveClientConfigTransactionPath } from "./ClientConfigPath.js";
-import { readRegularFileText } from "./RegularFileRead.js";
-import { manualRegistrationRemediation, supportedClients, } from "./SupportedClients.js";
-const systemFileSystem = {
-    readText: (path) => readRegularFileText(path),
-    readRegularText: readSkillFile,
+import { InvalidUtf8FileError, RegularFileCleanupFailure, readRegularFileText, } from "./RegularFileRead.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import { appDataRedirection, manualRegistrationRemediation, registrationWriteBlocker, supportedClients, } from "./SupportedClients.js";
+import { redirectedWriteBlocker, } from "./MsixPackageStorage.js";
+export { isUninstallFailure } from "./UninstallFailure.js";
+const systemFileSystem = (resources) => ({
+    readText: (path) => readRegularFileText(path, { resources }),
+    readRegularText: (path) => readSkillFile(path, resources),
     copy: (source, destination) => copyFile(source, destination, fsConstants.COPYFILE_EXCL),
     writeText: (path, contents) => writeFileAtomic(path, contents, { encoding: "utf8" }),
     stat: (path) => lstat(path),
     realpath: (path) => realpath(path),
     remove: (path, recursive = true) => rm(path, { recursive }),
-};
-/** Whether any requested REA-owned uninstall action failed. */
-export const isUninstallFailure = (result) => {
-    const status = result.status;
-    switch (status) {
-        case "complete":
-            return false;
-        case "failed":
-            return true;
-        default: {
-            const exhaustive = status;
-            throw new TypeError(`Unhandled uninstall result status: ${String(exhaustive)}`);
-        }
-    }
-};
+    removeEmptyDirectory: (path) => rmdir(path),
+});
 /**
  * Remove only REA-owned registrations and managed files, optionally including
  * local state. A client configuration that cannot be read safely stops the
@@ -41,31 +33,64 @@ export const isUninstallFailure = (result) => {
  * the remaining removals.
  */
 export const runUninstall = async (purgeData, host = systemUninstallHost()) => {
-    const clients = await host.clients();
-    const blocked = [];
-    for (const client of clients) {
-        const blocking = await host.inspectClient(client);
-        if (blocking !== undefined)
-            blocked.push(blocking);
-    }
-    const items = blocked.length > 0
-        ? [
-            ...blocked,
-            item("uninstall", "skipped", "No REA registration, skill, or data was removed. Repair each failed configuration, then rerun uninstall."),
-        ]
-        : await removeAll(clients, purgeData, host);
-    items.push({
-        name: "analysis_engine",
-        status: "retained",
-        detail: "Hopper is not owned by REA uninstall.",
-    });
-    const reported = collapseUninstallItems(items);
-    return {
-        status: reported.some(({ status }) => status === "failed")
-            ? "failed"
-            : "complete",
-        items: reported,
-    };
+    let result;
+    let primaryFailure;
+    let failed = false;
+    try {
+        const clients = await host.clients();
+        const blocked = [];
+        for (const client of clients) {
+            const blocking = await host.inspectClient(client);
+            if (blocking !== undefined)
+                blocked.push(blocking);
+        }
+        const skillBlocker = await host.inspectSkill?.();
+        if (skillBlocker !== undefined)
+            blocked.push(skillBlocker);
+        const items = blocked.length > 0
+            ? [
+                ...blocked,
+                item("uninstall", "skipped", "No REA registration, skill, or data was removed. Repair each failed configuration, then rerun uninstall."),
+            ]
+            : await removeAll(clients, purgeData, host);
+        items.push({
+            name: "analysis_engine",
+            status: "retained",
+            detail: "Hopper is not owned by REA uninstall.",
+        });
+        const reported = collapseUninstallItems(items);
+        result = {
+            status: reported.some(({ status }) => status === "failed")
+                ? "failed"
+                : "complete",
+            items: reported,
+        };
+    }
+    catch (cause) {
+        failed = true;
+        primaryFailure = cause;
+    }
+    let cleanupFailure;
+    try {
+        cleanupFailure = await host.close?.();
+    }
+    catch (cause) {
+        cleanupFailure = `Uninstall resource cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+    }
+    if (failed) {
+        if (cleanupFailure !== undefined)
+            throw new AggregateError([primaryFailure, new Error(cleanupFailure)], "Uninstall failed and its resource cleanup remains incomplete.", { cause: primaryFailure });
+        throw primaryFailure;
+    }
+    if (result === undefined)
+        throw new Error("Uninstall result was not produced.");
+    if (cleanupFailure === undefined)
+        return result;
+    const items = collapseUninstallItems([
+        ...result.items,
+        item("uninstall_cleanup", "failed", cleanupFailure),
+    ]);
+    return { status: "failed", items };
 };
 /**
  * Each client is reread when it is edited, so a concurrent change is never
@@ -88,29 +113,103 @@ const removeAll = async (clients, purgeData, host) => {
     return items;
 };
 /** Create uninstall effects contained to detected client configs and REA-owned paths. */
-export const systemUninstallHost = (selectedHome = undefined, fileSystem = systemFileSystem, environment = process.env, platform = process.platform) => {
+export const systemUninstallHost = (selectedHome = undefined, selectedFileSystem = undefined, environment = process.env, platform = process.platform) => {
     const home = selectedHome ?? homeDirectoryFromEnvironment(environment, platform);
+    const resources = new ArtifactResourceScope();
+    const fileSystem = selectedFileSystem ?? systemFileSystem(resources);
+    // Set with the client list: the package view that redirects this
+    // process's AppData writes, if any.
+    let redirection;
+    const clientWriteBlocker = (client) => registrationWriteBlocker(client, "uninstall") ??
+        redirectedWriteBlocker(redirection, [client.configPath], "uninstall");
+    const skillWriteBlocker = (path) => redirectedWriteBlocker(redirection, [path], "uninstall");
     return {
-        clients: () => Promise.resolve(supportedClients(home, platform, environment).flatMap((client) => client.configPaths === undefined
-            ? [client]
-            : client.configPaths.map((configPath) => ({
-                ...client,
-                configPath,
-            })))),
+        clients: () => {
+            const clients = supportedClients(home, platform, environment);
+            redirection = appDataRedirection(clients);
+            return Promise.resolve(clients.flatMap((client) => [
+                ...uninstallConfigPaths(client).map((configPath) => ({
+                    ...client,
+                    configPath,
+                })),
+                ...(client.zcodeFallbackPath === undefined
+                    ? []
+                    : [
+                        {
+                            ...client,
+                            configPath: client.zcodeFallbackPath,
+                            format: "zcode_fallback",
+                        },
+                    ]),
+            ]));
+        },
         inspectClient: async (client) => {
             const read = await readClientConfiguration(client, fileSystem);
-            return read.kind === "item" && read.item.status === "failed"
-                ? read.item
-                : undefined;
+            if (read.kind === "item")
+                return read.item.status === "failed" ? read.item : undefined;
+            const removal = clientRegistrationRemoval(read.parsed, client);
+            if (!removal.removeNative && removal.legacyPath === undefined)
+                return undefined;
+            // A removal the running package would revert, or redirect into its
+            // private storage, would leave the registration in place.
+            const blocker = clientWriteBlocker(client);
+            return blocker === undefined
+                ? undefined
+                : item(client.name, "failed", blocker);
+        },
+        removeClient: (client) => removeClient(client, fileSystem, () => clientWriteBlocker(client)),
+        inspectSkill: async () => {
+            for (const destination of skillDestinations(home, undefined, environment, platform)) {
+                const inspected = await inspectManagedSkill(destination.path, destination.client, fileSystem);
+                if (inspected?.status === "failed")
+                    return inspected;
+                if (inspected !== undefined)
+                    continue;
+                const blocker = skillWriteBlocker(destination.path);
+                if (blocker !== undefined)
+                    return item("skill", "failed", blocker);
+            }
+            return undefined;
+        },
+        removeSkill: () => removeManagedSkills(home, fileSystem, environment, platform, skillWriteBlocker),
+        purgeData: () => purgeManagedData(join(home, ".rea"), fileSystem),
+        close: async () => {
+            try {
+                await resources.close();
+                return undefined;
+            }
+            catch (cause) {
+                return `Uninstall resource cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+            }
         },
-        removeClient: (client) => removeClient(client, fileSystem),
-        removeSkill: () => removeManagedSkills(home, fileSystem, environment, platform),
-        purgeData: async () => [
-            await removeManagedPath(join(home, ".rea/cache"), "cache", fileSystem),
-            await removeManagedPath(join(home, ".rea/state"), "state", fileSystem),
-        ],
     };
 };
+/**
+ * Every user file that can hold REA's registration for one client. An MSIX
+ * package can read either its private copy or the AppData file, and earlier
+ * setups wrote the AppData file, so both lose REA's entry.
+ */
+const uninstallConfigPaths = (client) => [
+    ...new Set([
+        ...(client.configPaths ?? [client.configPath]),
+        ...(client.msixPackage === undefined
+            ? []
+            : [
+                client.msixPackage.privateConfigPath,
+                client.msixPackage.appDataConfigPath,
+            ]),
+    ]),
+];
+/** Whether removal would change this configuration. */
+const registrationPresent = (parsed) => {
+    const name = PRODUCT_IDENTITY.mcpServerKey;
+    return (Object.hasOwn(parsed.servers, name) ||
+        // Beside a native OpenCode V2 table, OpenCode also loads a V1 `mcp.rea`.
+        legacyClientServerPath(parsed, name) !== undefined ||
+        // Harness ownership is the stable entry id. A stale or malformed launcher
+        // still belongs to that id, and so does a direct patch that projects no row.
+        (parsed.dialect === "dsh" && dshDocument(parsed.document).carriesEntry));
+};
 const readClientConfiguration = async (client, fileSystem) => {
     if (client.configPathError !== undefined)
         return itemRead(item(client.name, "failed", client.configPathError));
@@ -126,46 +225,73 @@ const readClientConfiguration = async (client, fileSystem) => {
         original = await fileSystem.readText(transactionPath);
     }
     catch (cause) {
+        const readFailure = cause instanceof RegularFileCleanupFailure ? cause.cause : cause;
         return itemRead(isMissing(cause)
             ? item(client.name, "skipped", "Configuration does not exist.")
-            : item(client.name, "failed", "Configuration could not be read. Check file permissions, then rerun uninstall."));
+            : item(client.name, "failed", readFailure instanceof InvalidUtf8FileError
+                ? "Configuration is not valid UTF-8 and was not changed. Repair it, then rerun uninstall."
+                : "Configuration could not be read. Check file permissions, then rerun uninstall."));
     }
     try {
         const parsed = parseClientConfiguration(original, client.format);
         return { kind: "configuration", transactionPath, original, parsed };
     }
     catch (cause) {
-        void cause;
-        return itemRead(item(client.name, "failed", `Configuration is not valid ${client.format === "toml" || client.format === "grok" ? "TOML" : client.format === "opencode" ? "JSONC" : "JSON"} and was not changed. Repair it, then rerun uninstall.`));
+        return itemRead(item(client.name, "failed", cause instanceof ClientConfigurationShapeError
+            ? `Configuration was not changed: ${cause.message}. Repair it, then rerun uninstall.`
+            : `Configuration is not valid ${client.format === "toml" || client.format === "grok" ? "TOML" : client.format === "opencode" ? "JSONC" : client.format === "hermes" || client.format === "dsh" ? "YAML" : "JSON"} and was not changed. Repair it, then rerun uninstall.`));
     }
 };
 const itemRead = (result) => ({
     kind: "item",
     item: result,
 });
-const removeClient = async (client, fileSystem) => {
+/**
+ * Share the exact ownership and applicability decision with preflight. A
+ * removable legacy entry carries its document path, so removal edits exactly
+ * the entry this decision admitted.
+ */
+const clientRegistrationRemoval = (parsed, client) => {
+    const name = PRODUCT_IDENTITY.mcpServerKey;
+    if (parsed.dialect === "dsh" &&
+        dshDocument(parsed.document).hasUnknownStructure)
+        return { removeNative: false, legacyPath: undefined };
+    const legacyPath = legacyClientServerPath(parsed, name);
+    return {
+        removeNative: (parsed.dialect === "dsh" && dshDocument(parsed.document).carriesEntry) ||
+            (Object.hasOwn(parsed.servers, name) &&
+                isOwnedRegistration(parsed.servers[name], client)),
+        legacyPath: legacyPath !== undefined &&
+            isOwnedRegistration(parsed.legacyServers[name], client)
+            ? legacyPath
+            : undefined,
+    };
+};
+const removeClient = async (client, fileSystem, writeBlocker) => {
     const read = await readClientConfiguration(client, fileSystem);
     if (read.kind === "item")
         return read.item;
     const { transactionPath, original, parsed } = read;
     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)
+    if (parsed.dialect === "dsh" &&
+        dshDocument(parsed.document).hasUnknownStructure)
+        return item(client.name, "retained", "A Cordis expression may produce registration rows, so the patch was retained without changes.");
+    if (!registrationPresent(parsed))
         return item(client.name, "skipped", "REA registration is absent.");
-    const removeNative = hasNative && isOwnedRegistration(parsed.servers[name], client);
-    const removeLegacy = legacyPath !== undefined &&
-        isOwnedRegistration(parsed.legacyServers[name], client);
+    const { removeNative, legacyPath } = clientRegistrationRemoval(parsed, client);
+    const removeLegacy = legacyPath !== undefined;
     if (!removeNative && !removeLegacy)
         return item(client.name, "retained", "The rea-named registration is not REA-owned.");
+    const blocker = writeBlocker?.();
+    if (blocker !== undefined)
+        return item(client.name, "failed", blocker);
     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] : []),
+        ...(legacyPath === undefined ? [] : [legacyPath]),
     ];
     const backupPath = `${client.configPath}.rea.backup`;
     try {
@@ -179,6 +305,8 @@ const removeClient = async (client, fileSystem) => {
         await fileSystem.writeText(transactionPath, serializeClientConfiguration(document, client.format, original, editedPaths));
         const readback = parseClientConfiguration(await fileSystem.readText(transactionPath), client.format);
         if ((removeNative && Object.hasOwn(readback.servers, name)) ||
+            (readback.dialect === "dsh" &&
+                dshDocument(readback.document).carriesEntry) ||
             (removeLegacy && Object.hasOwn(readback.legacyServers, name)))
             throw new Error("registration readback mismatch");
         return item(client.name, "removed", `Removed registration from ${client.configPath}.`);
@@ -213,13 +341,31 @@ const isOwnedRegistration = (value, client) => {
         if (!parsed.success)
             return false;
         const command = parsed.data.command;
-        return isOwnedClientRegistrationCommand(command);
+        return isOwnedClientRegistrationCommand(command, CURRENT_ENTRYPOINT_PATH);
     }
     const parsed = registrationSchema.safeParse(value);
     if (!parsed.success)
         return false;
     const { command, args } = parsed.data;
-    return isOwnedClientRegistrationCommand([command, ...args]);
+    return isOwnedClientRegistrationCommand([command, ...args], CURRENT_ENTRYPOINT_PATH);
+};
+const purgeManagedData = async (root, fileSystem) => {
+    const names = ["cache", "state"];
+    try {
+        const stats = await fileSystem.stat(root);
+        const linked = stats.isSymbolicLink();
+        if (linked || stats.isDirectory?.() !== true)
+            return names.map((name) => item(name, "retained", `REA did not remove this item because its managed data root ${root} is ${linked ? "a symbolic link" : "not a directory"}. Verify the root before removing its data manually.`));
+    }
+    catch (cause) {
+        return names.map((name) => isMissing(cause)
+            ? item(name, "skipped", `${join(root, name)} does not exist.`)
+            : item(name, "failed", `The managed data root ${root} could not be verified. Check its permissions, then rerun uninstall.`));
+    }
+    const items = [];
+    for (const name of names)
+        items.push(await removeManagedPath(join(root, name), name, fileSystem));
+    return items;
 };
 const removeManagedPath = async (path, name, fileSystem) => {
     try {
@@ -235,8 +381,9 @@ const removeManagedPath = async (path, name, fileSystem) => {
             : item(name, "failed", "This item could not be removed. Check file permissions, then rerun uninstall.");
     }
 };
-const removeManagedSkills = async (home, fileSystem, environment, platform) => {
-    const results = await Promise.all(skillDestinations(home, undefined, environment, platform).map(({ client, path }) => removeManagedSkill(path, client === "claude_code" ? "Claude Code skill" : "skill", fileSystem)));
+const removeManagedSkills = async (home, fileSystem, environment, platform, writeBlocker) => {
+    // Every destination shares one summary item; preserve both client and path.
+    const results = await Promise.all(skillDestinations(home, undefined, environment, platform).map(({ client, path }) => removeManagedSkill(path, `${client} (${path})`, fileSystem, writeBlocker)));
     const failed = results.find(({ status }) => status === "failed");
     if (failed !== undefined)
         return item("skill", "failed", results
@@ -251,7 +398,7 @@ const removeManagedSkills = async (home, fileSystem, environment, platform) => {
         .map(({ name, status: resultStatus, detail }) => `${name}: ${resultStatus} (${detail})`)
         .join(" "));
 };
-const removeManagedSkill = async (path, name, fileSystem) => {
+const inspectManagedSkill = async (path, name, fileSystem) => {
     let root;
     try {
         root = await fileSystem.stat(path);
@@ -290,6 +437,15 @@ const removeManagedSkill = async (path, name, fileSystem) => {
     }
     if (!isManagedSkillManifest(content))
         return item(name, "retained", "Skill manifest is not REA-owned.");
+    return undefined;
+};
+const removeManagedSkill = async (path, name, fileSystem, writeBlocker) => {
+    const inspection = await inspectManagedSkill(path, name, fileSystem);
+    if (inspection !== undefined)
+        return inspection;
+    const blocker = writeBlocker?.(path);
+    if (blocker !== undefined)
+        return item(name, "failed", blocker);
     const manifestName = "SKILL.md";
     const otherFiles = MANAGED_SKILL_FILES.filter((relativePath) => relativePath !== manifestName);
     const results = [];
@@ -297,14 +453,49 @@ const removeManagedSkill = async (path, name, fileSystem) => {
         results.push(await removeManagedSkillFile(path, relativePath, name, fileSystem));
     if (results.some(({ status }) => status === "failed" || status === "retained"))
         results.push(item(name, "retained", "REA ownership manifest was retained because a managed file could not be safely removed."));
-    else
-        results.push(await removeManagedSkillFile(path, manifestName, name, fileSystem));
+    else {
+        const manifest = await removeManagedSkillFile(path, manifestName, name, fileSystem);
+        results.push(manifest);
+        const directories = manifest.status === "removed"
+            ? await removeEmptyManagedDirectories(path, name, fileSystem)
+            : undefined;
+        if (directories !== undefined)
+            results.push(directories);
+    }
     const failed = results.find(({ status }) => status === "failed");
     if (failed !== undefined)
         return item(name, "failed", results.map(({ detail }) => detail).join(" "));
+    if (results.some(({ status }) => status === "retained"))
+        return item(name, "retained", [...new Set(results.map(({ detail }) => detail))].join(" "));
     const removed = results.some(({ status }) => status === "removed");
     return item(name, removed ? "removed" : "skipped", "REA-managed skill files were removed; other files were preserved.");
 };
+/** Directories setup creates for managed files, deepest first, then the root. */
+const MANAGED_SKILL_DIRECTORIES = [
+    ...new Set(MANAGED_SKILL_FILES.map((relativePath) => relativePath.split("/").slice(0, -1).join("/")).filter((directory) => directory.length > 0)),
+].sort((left, right) => right.split("/").length - left.split("/").length);
+/** Remove managed directories left empty; any remaining user file keeps them. */
+const removeEmptyManagedDirectories = async (root, name, fileSystem) => {
+    if (fileSystem.removeEmptyDirectory === undefined)
+        return undefined;
+    for (const directory of [
+        ...MANAGED_SKILL_DIRECTORIES.map((relative) => join(root, relative)),
+        root,
+    ]) {
+        try {
+            await fileSystem.removeEmptyDirectory(directory);
+        }
+        catch (cause) {
+            // User files, an absent directory, or a non-directory keep it as is.
+            if (!isKeptDirectory(cause))
+                return item(name, "failed", `Managed skill directory could not be removed: ${directory}.`);
+        }
+    }
+    return undefined;
+};
+const isKeptDirectory = (cause) => cause instanceof Error &&
+    "code" in cause &&
+    ["ENOTEMPTY", "EEXIST", "ENOENT", "ENOTDIR"].includes(String(cause.code));
 const removeManagedSkillFile = async (root, relativePath, name, fileSystem) => {
     const segments = relativePath.split(/[\\/]/u);
     let parent = root;

package/dist/application/UninstallFailure.js

@@ -0,0 +1,14 @@
+/** Whether any requested REA-owned uninstall action failed. */
+export const isUninstallFailure = (result) => {
+    const status = result.status;
+    switch (status) {
+        case "complete":
+            return false;
+        case "failed":
+            return true;
+        default: {
+            const exhaustive = status;
+            throw new TypeError(`Unhandled uninstall result status: ${String(exhaustive)}`);
+        }
+    }
+};

package/dist/application/Update.js

@@ -1,30 +1,30 @@
 import { gt, valid } from "semver";
 import { PRODUCT_IDENTITY } from "../identity.js";
-/** Whether the update command left the requested release unapplied. */
-export const isUpdateFailure = (result) => {
-    const status = result.status;
-    switch (status) {
-        case "current":
-        case "updated":
-            return false;
-        case "failed":
-            return true;
+export { isUpdateFailure } from "./UpdateFailure.js";
+/** Resolve the exact package-manager command for the identified installation and release. */
+export const updateInstallCommand = (installation, version) => {
+    const release = `${PRODUCT_IDENTITY.packageName}@${version}`;
+    const manager = installation.manager;
+    switch (manager) {
+        case "npm":
+            return [
+                "npm",
+                "install",
+                "--global",
+                "--ignore-scripts",
+                "--prefix",
+                installation.prefix,
+                release,
+            ];
+        case "bun":
+            // The host pins Bun's global directory and working directory for this command.
+            return ["bun", "add", "--global", "--ignore-scripts", release];
         default: {
-            const exhaustive = status;
-            throw new TypeError(`Unhandled update result status: ${String(exhaustive)}`);
+            const exhaustive = manager;
+            throw new TypeError(`Unhandled installation manager: ${String(exhaustive)}`);
         }
     }
 };
-/** Resolve the exact npm command for the identified prefix and release. */
-export const updateInstallCommand = (installation, version) => [
-    "npm",
-    "install",
-    "--global",
-    "--ignore-scripts",
-    "--prefix",
-    installation.prefix,
-    `${PRODUCT_IDENTITY.packageName}@${version}`,
-];
 const versionCheckRemediation = (release) => {
     if (release.ok) {
         return "REA received invalid version metadata. Check the installed version and npm registry, then rerun rea update.";
@@ -32,6 +32,8 @@ const versionCheckRemediation = (release) => {
     const failure = release.error;
     const kind = failure.kind;
     switch (kind) {
+        case "unsupported-package-manager":
+            return failure.detail;
         case "unavailable":
             return `REA could not resolve the latest release: ${failure.detail}. Retry rea update when registry access is available.`;
         case "invalid-metadata":
@@ -44,6 +46,33 @@ const versionCheckRemediation = (release) => {
 };
 /** Identify, resolve, install, and verify REA without applying setup changes. */
 export const runUpdate = async (currentVersion, host, output = "human") => {
+    let result;
+    let primaryFailure;
+    let failed = false;
+    try {
+        result = await runUpdateWorkflow(currentVersion, host, output);
+    }
+    catch (cause) {
+        failed = true;
+        primaryFailure = cause;
+    }
+    let cleanupFailure;
+    try {
+        cleanupFailure = await host.close?.();
+    }
+    catch (cause) {
+        cleanupFailure = `Update resource cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+    }
+    if (failed) {
+        if (cleanupFailure !== undefined)
+            throw new AggregateError([primaryFailure, new Error(cleanupFailure)], "Update failed and its resource cleanup remains incomplete.", { cause: primaryFailure });
+        throw primaryFailure;
+    }
+    if (result === undefined)
+        throw new Error("Update result was not produced.");
+    return cleanupFailure === undefined ? result : { ...result, cleanupFailure };
+};
+const runUpdateWorkflow = async (currentVersion, host, output) => {
     const installation = await host.installation();
     const release = await host.latestVersion(installation);
     const latestVersion = release.ok ? release.value : null;
@@ -61,7 +90,7 @@ export const runUpdate = async (currentVersion, host, output = "human") => {
             status: "current",
             currentVersion,
             latestVersion: targetVersion,
-            installMethod: installation === undefined ? "unknown" : "npm",
+            installMethod: installation?.manager ?? "unknown",
         };
     if (installation === undefined)
         return {
@@ -78,7 +107,7 @@ export const runUpdate = async (currentVersion, host, output = "human") => {
             currentVersion,
             latestVersion: targetVersion,
             reason: "install",
-            remediation: `REA could not install ${targetVersion} in ${installation.prefix}: ${installed.error}. Repair this npm installation, then rerun rea update.`,
+            remediation: `REA could not install ${targetVersion} in ${installation.manager === "npm" ? installation.prefix : installation.globalDirectory}: ${installed.error}. Repair this ${installation.manager} installation, then rerun rea update.`,
         };
     const verified = await host.installedVersion(installation);
     if (!verified.ok || verified.value !== targetVersion)
@@ -88,7 +117,7 @@ export const runUpdate = async (currentVersion, host, output = "human") => {
             latestVersion: targetVersion,
             reason: "verification",
             ...(verified.ok ? { installedVersion: verified.value } : {}),
-            remediation: `npm completed, but REA could not verify ${targetVersion} in ${installation.packageRoot}: ${verified.ok ? `the executable reported ${verified.value}` : verified.error}. The installation may have changed; repair it before retrying.`,
+            remediation: `${installation.manager} completed, but REA could not verify ${targetVersion} in ${installation.packageRoot}: ${verified.ok ? `the executable reported ${verified.value}` : verified.error}. The installation may have changed; repair it before retrying.`,
         };
     const maintenance = await host.planMaintenance(installation);
     return {
@@ -96,7 +125,7 @@ export const runUpdate = async (currentVersion, host, output = "human") => {
         previousVersion: currentVersion,
         latestVersion: targetVersion,
         installedVersion: verified.value,
-        installMethod: "npm",
+        installMethod: installation.manager,
         command: updateInstallCommand(installation, targetVersion),
         maintenance,
         remediation: maintenance.status === "planned"

package/dist/application/UpdateFailure.js

@@ -0,0 +1,17 @@
+/** Whether the update command left the requested release unapplied. */
+export const isUpdateFailure = (result) => {
+    if (result.cleanupFailure !== undefined)
+        return true;
+    const status = result.status;
+    switch (status) {
+        case "current":
+        case "updated":
+            return false;
+        case "failed":
+            return true;
+        default: {
+            const exhaustive = status;
+            throw new TypeError(`Unhandled update result status: ${String(exhaustive)}`);
+        }
+    }
+};