rea-agents 1.2.0 → 1.4.0

package/dist/application/ProcessHarness.js

@@ -1,7 +1,7 @@
 import { spawn } from "node-pty";
 import { validateProcessCapture } from "../domain/processCapture.js";
 import { err, ok } from "../domain/result.js";
-import { ProcessCaptureError } from "./ProcessCaptureError.js";
+import { ProcessCaptureError, processCaptureCancelled, } from "./ProcessCaptureError.js";
 export { ProcessCaptureError } from "./ProcessCaptureError.js";
 import { startLoopbackReplay } from "./LoopbackReplay.js";
 import { startProcessSampler } from "./ProcessSampling.js";
@@ -98,7 +98,10 @@ const cleanupFailedStartup = async (options) => {
         sampledProcessGroupIds: [],
     });
     if (cleanupFailure !== undefined)
-        throw new ProcessCaptureError(cleanupFailure, { cause: options.cause });
+        throw new ProcessCaptureError(cleanupFailure, {
+            cause: options.cause,
+            reason: "cleanup_incomplete",
+        });
     throw options.cause;
 };
 const createTerminalRenderer = (scenario, temporaryRoot, terminalPid) => new TerminalRenderer({
@@ -218,7 +221,7 @@ const completeCapture = async (options) => {
     runtime.checkpoints.trigger("root_exit");
     const { reason } = options.exit;
     if (reason === "cancelled")
-        throw new ProcessCaptureError("process capture was cancelled");
+        throw processCaptureCancelled();
     const settlement = await observeSettlement(options.runId, [
         runtime.terminal.pid,
         ...options.samples.flatMap(({ process_group_id }) => process_group_id === null ? [] : [process_group_id]),

package/dist/application/ProgressReporter.js

@@ -0,0 +1,30 @@
+/** Create a monotonic, rate-bounded reporter around a surface-specific sink. */
+export const createProgressReporter = (sink, options = {}) => {
+    const minimumIntervalMs = options.minimumIntervalMs ?? 100;
+    const now = options.now ?? Date.now;
+    let lastCompleted = -1;
+    let lastSentAt = Number.NEGATIVE_INFINITY;
+    let sequence = 0;
+    return {
+        async report(update) {
+            if (!Number.isFinite(update.completed) || update.completed < 0)
+                throw new TypeError("Progress completed must be a nonnegative number");
+            if (update.total !== null && update.total < update.completed)
+                throw new TypeError("Progress total cannot be less than completed");
+            if (update.completed < lastCompleted)
+                throw new TypeError("Progress cannot move backwards");
+            lastCompleted = update.completed;
+            const observedAt = now();
+            if (update.terminal !== true &&
+                observedAt - lastSentAt < minimumIntervalMs)
+                return;
+            lastSentAt = observedAt;
+            sequence += 1;
+            await sink({ ...update, sequence });
+        },
+    };
+};
+/** Surface that deliberately ignores progress while preserving one workflow API. */
+export const silentProgressReporter = {
+    report: () => Promise.resolve(),
+};

package/dist/application/ProjectPermissionStore.js

@@ -0,0 +1,110 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, realpath, stat } from "node:fs/promises";
+import { dirname } from "node:path";
+import writeFileAtomic from "write-file-atomic";
+import { z } from "zod";
+import { err, ok } from "../domain/result.js";
+const grantSchema = z.object({
+    grant_id: z.string().min(1),
+    capability: z.enum([
+        "process_capture",
+        "evidence_read",
+        "evidence_write",
+        "investigation_input",
+        "investigation_workspace_read",
+        "investigation_workspace_write",
+        "snapshot_read",
+        "snapshot_write",
+        "artifact_extract",
+        "native_mount",
+        "reference_read",
+    ]),
+    roots: z.array(z.string()),
+    executables: z.array(z.string()),
+    environment_names: z.array(z.string()),
+    network: z.enum(["none", "loopback", "external"]),
+    mount: z.boolean(),
+    lifetime: z.literal("project"),
+    operation_identity: z.string().nullable(),
+    expires_at: z.iso.datetime().nullable(),
+});
+const storeSchema = z.object({
+    schema_version: z.literal(1),
+    project_id: z.string().regex(/^project_[a-f0-9]{64}$/u),
+    project_root: z.string(),
+    grants: z.array(grantSchema).max(1_000),
+});
+/** Owner-only project policy persistence failure. */
+export class ProjectPermissionStoreError extends Error {
+    reason;
+    _tag = "ProjectPermissionStoreError";
+    constructor(reason, options) {
+        super(`Project permission store failed: ${reason}`, options);
+        this.reason = reason;
+    }
+}
+/** Derive relocation-explicit project identity from its canonical root. */
+const identifyPermissionProject = async (projectRoot) => {
+    try {
+        const root = await realpath(projectRoot);
+        return ok({
+            id: `project_${createHash("sha256").update(root).digest("hex")}`,
+            root,
+        });
+    }
+    catch (cause) {
+        return err(new ProjectPermissionStoreError("project_not_found", { cause }));
+    }
+};
+/** Read and validate an owner-only store bound to the requested project. */
+export const readProjectPermissionStore = async (path, projectRoot) => {
+    const project = await identifyPermissionProject(projectRoot);
+    if (!project.ok)
+        return project;
+    try {
+        const metadata = await stat(path);
+        if ((metadata.mode & 0o077) !== 0)
+            return err(new ProjectPermissionStoreError("not_owner_only"));
+        const parsed = storeSchema.safeParse(JSON.parse(await readFile(path, "utf8")));
+        if (!parsed.success ||
+            parsed.data.project_id !== project.value.id ||
+            parsed.data.project_root !== project.value.root)
+            return err(new ProjectPermissionStoreError("invalid"));
+        return ok(parsed.data);
+    }
+    catch (cause) {
+        if (isNotFound(cause))
+            return ok(null);
+        return err(new ProjectPermissionStoreError("io", { cause }));
+    }
+};
+/** Atomically replace explicit project grants with owner-only permissions. */
+export const writeProjectPermissionStore = async (path, projectRoot, grants) => {
+    const project = await identifyPermissionProject(projectRoot);
+    if (!project.ok)
+        return project;
+    const candidate = storeSchema.safeParse({
+        schema_version: 1,
+        project_id: project.value.id,
+        project_root: project.value.root,
+        grants,
+    });
+    if (!candidate.success)
+        return err(new ProjectPermissionStoreError("invalid", { cause: candidate.error }));
+    try {
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        await writeFileAtomic(path, `${JSON.stringify(candidate.data, null, 2)}\n`, {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        const metadata = await stat(path);
+        if ((metadata.mode & 0o077) !== 0) {
+            return err(new ProjectPermissionStoreError("not_owner_only"));
+        }
+        return ok(candidate.data);
+    }
+    catch (cause) {
+        return err(new ProjectPermissionStoreError("io", { cause }));
+    }
+};
+const isNotFound = (cause) => cause instanceof Error && "code" in cause && cause.code === "ENOENT";

package/dist/application/ReferenceSourceImportEntries.js

@@ -3,16 +3,31 @@ import { posix } from "node:path";
 import { classifyReferenceSourcePath, detectReferenceSourceLanguage, } from "../domain/referenceSourceClassification.js";
 import { parseReferenceSourceImports } from "../domain/referenceSourceImportParsing.js";
 import { PARSEABLE_REFERENCE_SOURCE_LANGUAGES } from "./ReferenceSourceImportTypes.js";
+/** Project a low-level entry failure into safe import guidance. */
+export const projectReferenceSourceEntryFailure = (entry) => {
+    if (entry.code === "cancelled")
+        return "This entry was not read because the import was cancelled. Start the import again when ready.";
+    if (entry.code === "limit")
+        return "This entry was not read because an import limit was reached. Import a smaller directory or raise the configured limits.";
+    if (entry.code === "unsupported")
+        return "This entry cannot be read safely on this system. Exclude it or import the directory on a supported system.";
+    if (entry.kind === "directory")
+        return "This directory could not be read. Check its permissions, then try again.";
+    if (entry.kind === "symlink")
+        return "This symbolic link could not be read safely. Check the link and its permissions, then try again.";
+    return "This file could not be read. Check its permissions, then try again.";
+};
 const hashBytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
 const failedEntry = (entry) => {
     const classifications = classifyReferenceSourcePath(entry.path);
+    const limitation = projectReferenceSourceEntryFailure(entry);
     if (entry.kind === "directory")
         return {
             path: entry.path,
             kind: "directory",
             classifications,
             tree_state: entry.code === "limit" ? "partial" : "unreadable",
-            limitations: [entry.message],
+            limitations: [limitation],
         };
     if (entry.kind === "symlink")
         return {
@@ -21,7 +36,7 @@ const failedEntry = (entry) => {
             target: "<unreadable>",
             target_state: "unreadable",
             classifications,
-            limitations: [entry.message],
+            limitations: [limitation],
         };
     return {
         path: entry.path,
@@ -31,7 +46,7 @@ const failedEntry = (entry) => {
         language: null,
         classifications: entry.kind === "file" ? classifications : ["unknown"],
         content_state: entry.code === "limit" ? "too-large" : "unreadable",
-        limitations: [entry.message],
+        limitations: [limitation],
     };
 };
 const resolveInternalSpecifier = (fromPath, specifier, filePaths) => {

package/dist/application/ReferenceSourceImportTypes.js

@@ -1,3 +1,35 @@
+/** Safe CLI projection for a historical-source import failure. */
+export const projectReferenceSourceImportError = (error) => {
+    if (error.code === "cancelled")
+        return {
+            category: "cancelled",
+            message: "Reference source import was cancelled. Start it again when ready.",
+        };
+    if (error.code === "invalid-limits")
+        return {
+            category: "invalid_input",
+            message: "Reference source limits are invalid. Use positive integer limits, then try again.",
+        };
+    if (error.code === "invalid-root")
+        return {
+            category: "invalid_input",
+            message: "Reference source directory could not be opened. Check that the path exists, is readable, and points to a directory.",
+        };
+    if (error.code === "policy")
+        return {
+            category: "permission_required",
+            message: "Reference source directory is not approved. Add its directory to `REA_REFERENCE_ROOTS_JSON`, restart REA, then try again.",
+        };
+    if (error.code === "io")
+        return {
+            category: "execution_failure",
+            message: "Reference source files could not be read. Check directory permissions and try again.",
+        };
+    return {
+        category: "execution_failure",
+        message: "Reference source could not be indexed. Check that the source tree is readable, then try again.",
+    };
+};
 export const DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS = [
     ".git/",
     ".git/hooks/",

package/dist/application/Setup.js

@@ -1,6 +1,6 @@
 import { access, copyFile, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { z } from "zod";
 import writeFileAtomic from "write-file-atomic";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
@@ -9,50 +9,15 @@ 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 { installCanonicalSkill } from "./SetupSkill.js";
+import { setupPlan } from "./SetupPlan.js";
+import { setupInstallFailure, } from "./SetupInstallFailure.js";
 export { installCanonicalSkill } from "./SetupSkill.js";
 const registrationCommand = () => process.env.npm_command === "exec"
     ? ["npx", "-y", PRODUCT_IDENTITY.packageName, "mcp"]
     : [resolve(process.argv[1] ?? PRODUCT_IDENTITY.cliBinary), "mcp"];
-const setupPlan = (platform, hopperPath, clients) => [
-    ...(hopperPath === undefined
-        ? [
-            {
-                kind: "install_hopper",
-                target: platform === "darwin"
-                    ? "~/Applications/Hopper Disassembler.app"
-                    : "system package manager",
-                detail: "Download the official Hopper package, verify it, install it, and open Hopper for activation.",
-                external: true,
-            },
-        ]
-        : []),
-    ...clients
-        .filter(({ format }) => format !== "unsupported")
-        .map((client) => ({
-        kind: "configure_client",
-        target: client.configPath,
-        detail: `Add the REA MCP registration for ${client.name}; preserve unrelated configuration.`,
-        external: false,
-    })),
-    {
-        kind: "install_skill",
-        target: "~/.agents/skills/rea-analysis/SKILL.md",
-        detail: "Install or update the bundled REA analysis skill.",
-        external: false,
-    },
-];
-const configureDetectedClients = async (options) => {
-    for (const client of options.detectedClients) {
-        const result = await options.host.configureClient(client, options.hopperPath, registrationCommand());
-        options.clients[client.name] = result;
-        if (result.status === "failed")
-            return `${client.name} configuration ${result.reason} verification failed; no successful configuration was reported.`;
-        if (result.status === "configured")
-            options.appliedActions.push(`configured_${client.name}`);
-    }
-    return undefined;
-};
 /**
  * Install prerequisites and configure detected clients idempotently.
  * Discovery always precedes mutation. Interactive confirmation or explicit
@@ -74,8 +39,13 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
     if (unsupported !== undefined)
         return fail(unsupported);
     let hopperPath = await host.hopperPath();
+    const initialDoctor = await host.doctor();
+    const linuxHopperRepairNeeded = initialDoctor.checks.some(({ name, ok, detail }) => !ok &&
+        (name === "hopper-demo-runtime" ||
+            (name === "hopper-version" && detail === "/opt/hopper/bin/Hopper")));
+    const installHopper = hopperPath === undefined || linuxHopperRepairNeeded;
     const detectedClients = await host.detectedClients();
-    plannedActions = setupPlan(host.platform, hopperPath, detectedClients);
+    plannedActions = setupPlan(host.platform, installHopper, detectedClients);
     let approved = options.approved;
     let interactiveApproval = false;
     if (!approved && confirm !== undefined && !options.structured) {
@@ -91,24 +61,26 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
             doctor: await host.doctor(),
             remediation: "Review the setup plan, then rerun interactively or with --yes.",
         };
-    if (hopperPath === undefined &&
-        (interactiveApproval || options.installHopper)) {
-        hopperPath = await host.installHopper();
-        if (hopperPath === undefined)
+    if (installHopper && (interactiveApproval || options.installHopper)) {
+        const installed = await host.installHopper();
+        if (installed.status === "failed")
             return {
                 status: "needs_human",
                 plannedActions,
                 appliedActions,
                 clients,
                 doctor: await host.doctor(),
-                remediation: "Hopper installation failed; install Hopper manually or rerun setup after resolving the reported system error.",
+                code: installed.code,
+                remediation: installed.remediation,
             };
+        hopperPath = installed.launcherPath;
         appliedActions.push("installed_hopper");
     }
     const clientFailure = await configureDetectedClients({
         host,
         detectedClients,
         hopperPath,
+        command: registrationCommand(),
         clients,
         appliedActions,
     });
@@ -116,29 +88,29 @@ export const runSetup = async (options, host = systemSetupHost(), confirm) => {
         return fail(clientFailure);
     const skill = await host.installSkill();
     if (skill === "failed")
-        return fail("Agent skill installation or readback failed.");
+        return fail("REA analysis skill could not be installed or verified. Check permissions for `~/.agents/skills`, then rerun setup.");
     if (skill === "installed")
         appliedActions.push("installed_skill");
     const doctor = await host.doctor();
-    const activationRequired = appliedActions.includes("installed_hopper");
-    const ready = doctor.healthy && !activationRequired;
+    const remediation = finalSetupRemediation(host.platform, appliedActions.includes("installed_hopper"), doctor.healthy, hopperPath);
     return {
-        status: ready ? "ready" : "needs_human",
+        status: remediation === undefined ? "ready" : "needs_human",
         plannedActions,
         appliedActions,
         clients,
         doctor,
-        ...(ready
-            ? {}
-            : {
-                remediation: activationRequired
-                    ? "Open Hopper, complete its one-time activation, then rerun rea doctor --json."
-                    : hopperPath === undefined
-                        ? "Hopper is optional for non-Hopper providers. Rerun with --yes --install-hopper for deep native analysis."
-                        : "Run rea doctor and apply each reported remediation.",
-            }),
+        ...(remediation === undefined ? {} : { remediation }),
     };
 };
+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.";
+    if (healthy)
+        return undefined;
+    return hopperPath === undefined
+        ? "Hopper is optional for non-Hopper providers. Rerun with --yes --install-hopper for deep native analysis."
+        : "Run rea doctor and apply each reported remediation.";
+};
 const hostRemediation = async (host) => {
     if (host.platform !== "darwin" && host.platform !== "linux")
         return "REA supports Hopper on macOS and selected 64-bit Linux distributions.";
@@ -167,7 +139,9 @@ const systemSetupHost = () => {
             const result = process.platform === "linux"
                 ? await installLinuxHopper()
                 : await installMacHopper();
-            return result.status === "installed" ? result.launcherPath : undefined;
+            if (result.status === "installed")
+                return result;
+            return setupInstallFailure(result.reason);
         },
         detectedClients: () => detectClients(homedir()),
         configureClient: (client, hopperPath, command) => client.format === "unsupported"
@@ -179,7 +153,7 @@ const systemSetupHost = () => {
         doctor: () => runDoctor(undefined, doctorHost),
     };
 };
-/** Detect supported coding agents from stable per-user installation markers. */
+/** Detect supported agents from stable per-user installation markers. */
 export const detectClients = async (home) => {
     const detected = [];
     for (const candidate of supportedClients(home))
@@ -187,46 +161,6 @@ export const detectClients = async (home) => {
             detected.push(candidate);
     return detected;
 };
-/** Describe every client location that setup or uninstall may own. */
-export const supportedClients = (home) => [
-    {
-        name: "claude_code",
-        configPath: join(home, ".claude.json"),
-        markerPath: join(home, ".claude"),
-    },
-    {
-        name: "claude_desktop",
-        configPath: join(home, "Library/Application Support/Claude/claude_desktop_config.json"),
-        markerPath: join(home, "Library/Application Support/Claude"),
-    },
-    {
-        name: "codex",
-        configPath: join(home, ".codex/config.toml"),
-        markerPath: join(home, ".codex"),
-        format: "toml",
-    },
-    {
-        name: "cursor",
-        configPath: join(home, ".cursor/mcp.json"),
-        markerPath: join(home, ".cursor"),
-    },
-    {
-        name: "gemini_cli",
-        configPath: join(home, ".gemini/settings.json"),
-        markerPath: join(home, ".gemini"),
-    },
-    {
-        name: "windsurf",
-        configPath: join(home, ".codeium/windsurf/mcp_config.json"),
-        markerPath: join(home, ".codeium/windsurf"),
-    },
-    {
-        name: "devin",
-        configPath: join(home, ".devin"),
-        markerPath: join(home, ".devin"),
-        format: "unsupported",
-    },
-];
 /** Back up, atomically update, and semantically read back one JSON MCP configuration. */
 export const configureJsonClient = async (client, hopperPath, command = [
     "npx",

package/dist/application/SetupClients.js

@@ -0,0 +1,19 @@
+const failedConfigurationMessage = (reason) => {
+    if (reason === "backup")
+        return "Agent configuration could not be backed up, so no change was made. Check file permissions, then rerun setup.";
+    if (reason === "write")
+        return "Agent configuration could not be updated. Check file permissions, then rerun setup.";
+    return "Agent configuration could not be verified after writing. Repair the configuration file or restore its `.rea.backup`, then rerun setup.";
+};
+/** Configure each detected agent, stopping after the first failed transaction. */
+export const configureDetectedClients = async (options) => {
+    for (const client of options.detectedClients) {
+        const result = await options.host.configureClient(client, options.hopperPath, options.command);
+        options.clients[client.name] = result;
+        if (result.status === "failed")
+            return failedConfigurationMessage(result.reason);
+        if (result.status === "configured")
+            options.appliedActions.push(`configured_${client.name}`);
+    }
+    return undefined;
+};

package/dist/application/SetupInstallFailure.js

@@ -0,0 +1,53 @@
+/** Map provider installer failures to stable setup codes and safe recovery. */
+export const setupInstallFailure = (reason) => {
+    switch (reason) {
+        case "unsupported_host":
+            return {
+                status: "failed",
+                code: "unsupported_host",
+                remediation: "Use a supported host, then rerun rea setup.",
+            };
+        case "integrity":
+            return {
+                status: "failed",
+                code: "integrity_mismatch",
+                remediation: "The Hopper download failed integrity verification. Retry setup; if it repeats, update REA before installing.",
+            };
+        case "authorization_or_package_manager":
+            return {
+                status: "failed",
+                code: "authorization_or_package_manager_failed",
+                remediation: "Allow the system package-manager operation or install the planned Hopper package and Linux runtime dependencies, then rerun rea setup.",
+            };
+        case "launcher_missing":
+            return {
+                status: "failed",
+                code: "launcher_missing",
+                remediation: "The package operation completed but Hopper is not runnable. Run rea doctor and repair the reported launcher issue.",
+            };
+        case "runtime_dependencies":
+            return {
+                status: "failed",
+                code: "runtime_dependency_unavailable",
+                remediation: "Hopper was installed but required shared libraries are missing. Rerun rea setup, then apply the hopper-demo-runtime remediation from rea doctor.",
+            };
+        case "unsupported_hopper_build":
+            return {
+                status: "failed",
+                code: "unsupported_hopper_build",
+                remediation: "The installed Hopper launcher does not match the build supported by this REA release. Unset HOPPER_LAUNCHER_PATH, reinstall through rea setup, or update REA.",
+            };
+        case "cancelled":
+            return {
+                status: "failed",
+                code: "setup_cancelled",
+                remediation: "Setup was cancelled before Hopper was installed. Rerun rea setup when ready.",
+            };
+        default:
+            return {
+                status: "failed",
+                code: "download_failed",
+                remediation: "REA could not download or unpack the official Hopper package. Check network and filesystem access, then retry setup.",
+            };
+    }
+};

package/dist/application/SetupPlan.js

@@ -0,0 +1,31 @@
+/** Build the complete setup mutation plan before approval. */
+export const setupPlan = (platform, installHopper, clients) => [
+    ...(installHopper
+        ? [
+            {
+                kind: "install_hopper",
+                target: platform === "darwin"
+                    ? "~/Applications/Hopper Disassembler.app"
+                    : "system package manager",
+                detail: platform === "linux"
+                    ? "Download, verify, and install Hopper plus its Xvfb demo-session dependencies. For the supported demo build, REA uses a private display and selects Hopper's offered demo mode for each analysis session."
+                    : "Download the official Hopper package, verify it, and install it. Hopper may show its demo or license prompt when first opened.",
+                external: true,
+            },
+        ]
+        : []),
+    ...clients
+        .filter(({ format }) => format !== "unsupported")
+        .map((client) => ({
+        kind: "configure_client",
+        target: client.configPath,
+        detail: `Add the REA MCP registration for ${client.name}; preserve unrelated configuration.`,
+        external: false,
+    })),
+    {
+        kind: "install_skill",
+        target: "~/.agents/skills/rea-analysis/SKILL.md",
+        detail: "Install or update the bundled REA analysis skill.",
+        external: false,
+    },
+];

package/dist/application/SupportedClients.js

@@ -0,0 +1,41 @@
+import { join } from "node:path";
+/** Describe every client location that setup, doctor, or uninstall may inspect. */
+export const supportedClients = (home) => [
+    {
+        name: "claude_code",
+        configPath: join(home, ".claude.json"),
+        markerPath: join(home, ".claude"),
+    },
+    {
+        name: "claude_desktop",
+        configPath: join(home, "Library/Application Support/Claude/claude_desktop_config.json"),
+        markerPath: join(home, "Library/Application Support/Claude"),
+    },
+    {
+        name: "codex",
+        configPath: join(home, ".codex/config.toml"),
+        markerPath: join(home, ".codex"),
+        format: "toml",
+    },
+    {
+        name: "cursor",
+        configPath: join(home, ".cursor/mcp.json"),
+        markerPath: join(home, ".cursor"),
+    },
+    {
+        name: "gemini_cli",
+        configPath: join(home, ".gemini/settings.json"),
+        markerPath: join(home, ".gemini"),
+    },
+    {
+        name: "windsurf",
+        configPath: join(home, ".codeium/windsurf/mcp_config.json"),
+        markerPath: join(home, ".codeium/windsurf"),
+    },
+    {
+        name: "devin",
+        configPath: join(home, ".devin"),
+        markerPath: join(home, ".devin"),
+        format: "unsupported",
+    },
+];