@braid-cloud/cli 0.1.5 → 0.1.8

package/dist/index.js

@@ -47,6 +47,10 @@ __export(config_exports, {
   loadUserConfigAsync: () => loadUserConfigAsync,
   saveConfig: () => saveConfig,
   saveConfigAsync: () => saveConfigAsync,
+  saveProjectConfig: () => saveProjectConfig,
+  saveProjectConfigAsync: () => saveProjectConfigAsync,
+  saveUserConfig: () => saveUserConfig,
+  saveUserConfigAsync: () => saveUserConfigAsync,
   setApiKey: () => setApiKey,
   setApiKeyAsync: () => setApiKeyAsync
 });
@@ -56,7 +60,7 @@ import { homedir } from "os";
 import { dirname, join, parse } from "path";
 import process2 from "process";
 import { Data, Effect, pipe } from "effect";
-var CONFIG_DIR, CONFIG_FILE, PROJECT_CONFIG_FILENAME, USER_CONFIG_FILENAME, ConfigReadError, ConfigWriteError, findConfigFile, findProjectConfigFile, findUserConfigFile, loadProjectConfig, loadUserConfig, isValidServerUrl, resolveServerUrlFromConfig, applyConfigSource, applyEnvOverrides, createDefaultMergedConfig, loadMergedConfig, loadConfig, saveConfig, getApiKey, setApiKey, getServerUrl, clearApiKey, loadConfigAsync, loadProjectConfigAsync, loadUserConfigAsync, loadMergedConfigAsync, findProjectConfigFileAsync, findUserConfigFileAsync, saveConfigAsync, getApiKeyAsync, setApiKeyAsync, getServerUrlAsync, clearApiKeyAsync;
+var CONFIG_DIR, CONFIG_FILE, PROJECT_CONFIG_FILENAME, USER_CONFIG_FILENAME, ConfigReadError, ConfigWriteError, findConfigFile, findProjectConfigFile, findUserConfigFile, loadProjectConfig, loadUserConfig, resolveUserConfigWritePath, resolveProjectConfigWritePath, saveUserConfig, saveProjectConfig, isValidServerUrl, resolveServerUrlFromConfig, applyConfigSource, applyEnvOverrides, createDefaultMergedConfig, loadMergedConfig, loadConfig, saveConfig, getApiKey, setApiKey, getServerUrl, clearApiKey, loadConfigAsync, loadProjectConfigAsync, loadUserConfigAsync, loadMergedConfigAsync, findProjectConfigFileAsync, findUserConfigFileAsync, saveConfigAsync, saveUserConfigAsync, saveProjectConfigAsync, getApiKeyAsync, setApiKeyAsync, getServerUrlAsync, clearApiKeyAsync;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
@@ -107,6 +111,40 @@ var init_config = __esm({
       },
       catch: () => void 0
     }).pipe(Effect.orElseSucceed(() => void 0));
+    resolveUserConfigWritePath = (startDir = process2.cwd()) => findUserConfigFile(startDir) ?? join(startDir, USER_CONFIG_FILENAME);
+    resolveProjectConfigWritePath = (startDir = process2.cwd()) => findProjectConfigFile(startDir) ?? join(startDir, PROJECT_CONFIG_FILENAME);
+    saveUserConfig = (config, startDir = process2.cwd()) => {
+      const targetPath = resolveUserConfigWritePath(startDir);
+      return pipe(
+        Effect.tryPromise({
+          try: async () => {
+            await mkdir(dirname(targetPath), { recursive: true, mode: 448 });
+            await writeFile(targetPath, JSON.stringify(config, null, 2), {
+              encoding: "utf-8",
+              mode: 384
+            });
+            return targetPath;
+          },
+          catch: (e) => new ConfigWriteError({ path: targetPath, cause: e })
+        })
+      );
+    };
+    saveProjectConfig = (config, startDir = process2.cwd()) => {
+      const targetPath = resolveProjectConfigWritePath(startDir);
+      return pipe(
+        Effect.tryPromise({
+          try: async () => {
+            await mkdir(dirname(targetPath), { recursive: true, mode: 448 });
+            await writeFile(targetPath, JSON.stringify(config, null, 2), {
+              encoding: "utf-8",
+              mode: 384
+            });
+            return targetPath;
+          },
+          catch: (e) => new ConfigWriteError({ path: targetPath, cause: e })
+        })
+      );
+    };
     isValidServerUrl = (url) => {
       try {
         const parsed = new URL(url);
@@ -136,12 +174,24 @@ var init_config = __esm({
       if (config.profile) {
         merged.profile = config.profile;
       }
+      if (config.org) {
+        merged.org = config.org;
+      }
       if (config.orgProjects) {
         merged.orgProjects = config.orgProjects;
       }
       if (config.personalProjects) {
         merged.personalProjects = config.personalProjects;
       }
+      if (config.ruleIds) {
+        merged.ruleIds = config.ruleIds;
+      }
+      if (config.excludedRuleIds) {
+        merged.excludedRuleIds = config.excludedRuleIds;
+      }
+      if (config.resolveOverlays !== void 0) {
+        merged.resolveOverlays = config.resolveOverlays;
+      }
       if (config.includeUserGlobal !== void 0) {
         merged.includeUserGlobal = config.includeUserGlobal;
       }
@@ -261,6 +311,8 @@ var init_config = __esm({
     findProjectConfigFileAsync = (startDir) => findProjectConfigFile(startDir);
     findUserConfigFileAsync = (startDir) => findUserConfigFile(startDir);
     saveConfigAsync = (config) => Effect.runPromise(saveConfig(config));
+    saveUserConfigAsync = (config, startDir) => Effect.runPromise(saveUserConfig(config, startDir));
+    saveProjectConfigAsync = (config, startDir) => Effect.runPromise(saveProjectConfig(config, startDir));
     getApiKeyAsync = () => Effect.runPromise(getApiKey());
     setApiKeyAsync = (apiKey) => Effect.runPromise(setApiKey(apiKey));
     getServerUrlAsync = () => Effect.runPromise(getServerUrl());
@@ -268,172 +320,864 @@ var init_config = __esm({
   }
 });
 
-// src/index.ts
-init_esm_shims();
-import { createRequire } from "module";
-import { Command } from "commander";
-
-// src/commands/auth.ts
-init_esm_shims();
-import process3 from "process";
-import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  log,
-  outro,
-  password,
-  spinner
-} from "@clack/prompts";
-
 // src/lib/api.ts
-init_esm_shims();
-init_config();
 import { Data as Data2, Effect as Effect2, pipe as pipe2 } from "effect";
-var TRAILING_SLASH_REGEX = /\/$/;
-var ApiError = class extends Data2.TaggedError("ApiError") {
-};
-var AuthenticationError = class extends Data2.TaggedError("AuthenticationError") {
-};
-var NetworkError = class extends Data2.TaggedError("NetworkError") {
-};
-var resolveApiKey = (optionsApiKey) => {
-  if (optionsApiKey) {
-    return Effect2.succeed(optionsApiKey);
-  }
-  return pipe2(
-    Effect2.tryPromise({
-      try: () => getApiKeyAsync(),
-      catch: () => new NetworkError({ message: "Failed to read config" })
-    }),
-    Effect2.flatMap(
-      (key) => key ? Effect2.succeed(key) : Effect2.fail(
-        new AuthenticationError({
-          message: 'No API key configured. Run "braid auth" to authenticate.'
+var TRAILING_SLASH_REGEX, ApiError, AuthenticationError, NetworkError, resolveApiKey, resolveServerUrl, parseResponse, buildApiUrl, buildExportUrl, executeApiRequest, parseScopeOptionsResponse, fetchScopeOptions, buildRuleOptionsUrl, fetchRuleOptions, fetchSkills, validateApiKey, fetchSkillsAsync, validateApiKeyAsync, fetchScopeOptionsAsync, fetchRuleOptionsAsync;
+var init_api = __esm({
+  "src/lib/api.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    TRAILING_SLASH_REGEX = /\/$/;
+    ApiError = class extends Data2.TaggedError("ApiError") {
+    };
+    AuthenticationError = class extends Data2.TaggedError("AuthenticationError") {
+    };
+    NetworkError = class extends Data2.TaggedError("NetworkError") {
+    };
+    resolveApiKey = (optionsApiKey) => {
+      if (optionsApiKey) {
+        return Effect2.succeed(optionsApiKey);
+      }
+      return pipe2(
+        Effect2.tryPromise({
+          try: () => getApiKeyAsync(),
+          catch: () => new NetworkError({ message: "Failed to read config" })
+        }),
+        Effect2.flatMap(
+          (key) => key ? Effect2.succeed(key) : Effect2.fail(
+            new AuthenticationError({
+              message: 'No API key configured. Run "braid auth" to authenticate.'
+            })
+          )
+        )
+      );
+    };
+    resolveServerUrl = (optionsServerUrl) => {
+      if (optionsServerUrl) {
+        return Effect2.succeed(optionsServerUrl);
+      }
+      return Effect2.tryPromise({
+        try: () => getServerUrlAsync(),
+        catch: () => new NetworkError({ message: "Failed to read config" })
+      });
+    };
+    parseResponse = (response, json) => {
+      if (!response.ok) {
+        const errorResponse = json;
+        if (response.status === 401) {
+          return Effect2.fail(
+            new AuthenticationError({
+              message: errorResponse.error || "Invalid or expired API key. Run 'braid auth' to re-authenticate."
+            })
+          );
+        }
+        return Effect2.fail(
+          new ApiError({
+            message: errorResponse.error || "API request failed",
+            code: errorResponse.code || "UNKNOWN_ERROR",
+            status: response.status
+          })
+        );
+      }
+      return Effect2.succeed(json);
+    };
+    buildApiUrl = (serverUrl, path2) => {
+      const baseUrl = serverUrl.replace(TRAILING_SLASH_REGEX, "");
+      return new URL(`${baseUrl}${path2}`);
+    };
+    buildExportUrl = (serverUrl, options) => {
+      const url = buildApiUrl(serverUrl, "/api/skills/export");
+      if (options.profile) {
+        url.searchParams.set("profile", options.profile);
+      }
+      if (options.orgProjects && options.orgProjects.length > 0) {
+        url.searchParams.set("orgProjects", options.orgProjects.join(","));
+      }
+      if (options.personalProjects && options.personalProjects.length > 0) {
+        url.searchParams.set(
+          "personalProjects",
+          options.personalProjects.join(",")
+        );
+      }
+      if (options.includeUserGlobal !== void 0) {
+        url.searchParams.set(
+          "includeUserGlobal",
+          String(options.includeUserGlobal)
+        );
+      }
+      if (options.includeOrgGlobal !== void 0) {
+        url.searchParams.set("includeOrgGlobal", String(options.includeOrgGlobal));
+      }
+      if (options.ruleIds && options.ruleIds.length > 0) {
+        url.searchParams.set("ruleIds", options.ruleIds.join(","));
+      }
+      if (options.excludedRuleIds && options.excludedRuleIds.length > 0) {
+        url.searchParams.set("excludedRuleIds", options.excludedRuleIds.join(","));
+      }
+      if (options.resolveOverlays !== void 0) {
+        url.searchParams.set("resolveOverlays", String(options.resolveOverlays));
+      }
+      return url;
+    };
+    executeApiRequest = (url, apiKey, serverUrl) => pipe2(
+      Effect2.tryPromise({
+        try: () => fetch(url.toString(), {
+          method: "GET",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          }
+        }),
+        catch: (e) => new NetworkError({
+          message: `Failed to connect to ${serverUrl}`,
+          cause: e
         })
+      }),
+      Effect2.flatMap(
+        (response) => pipe2(
+          Effect2.tryPromise({
+            try: () => response.json(),
+            catch: () => new NetworkError({ message: "Failed to parse API response" })
+          }),
+          Effect2.flatMap((json) => parseResponse(response, json))
+        )
       )
-    )
-  );
-};
-var resolveServerUrl = (optionsServerUrl) => {
-  if (optionsServerUrl) {
-    return Effect2.succeed(optionsServerUrl);
-  }
-  return Effect2.tryPromise({
-    try: () => getServerUrlAsync(),
-    catch: () => new NetworkError({ message: "Failed to read config" })
-  });
-};
-var parseResponse = (response, json) => {
-  if (!response.ok) {
-    const errorResponse = json;
-    if (response.status === 401) {
-      return Effect2.fail(
-        new AuthenticationError({
-          message: errorResponse.error || "Invalid or expired API key. Run 'braid auth' to re-authenticate."
+    );
+    parseScopeOptionsResponse = (response, json) => {
+      if (!response.ok) {
+        const errorResponse = json;
+        if (response.status === 401) {
+          return Effect2.fail(
+            new AuthenticationError({
+              message: errorResponse.error || "Invalid or expired API key. Run 'braid auth' to re-authenticate."
+            })
+          );
+        }
+        return Effect2.fail(
+          new ApiError({
+            message: errorResponse.error || "API request failed",
+            code: errorResponse.code || "UNKNOWN_ERROR",
+            status: response.status
+          })
+        );
+      }
+      return Effect2.succeed(json);
+    };
+    fetchScopeOptions = (options = {}) => pipe2(
+      Effect2.all({
+        apiKey: resolveApiKey(options.apiKey),
+        serverUrl: resolveServerUrl(options.serverUrl)
+      }),
+      Effect2.flatMap(({ apiKey, serverUrl }) => {
+        const url = buildApiUrl(serverUrl, "/api/skills/scope-options");
+        return pipe2(
+          Effect2.tryPromise({
+            try: () => fetch(url.toString(), {
+              method: "GET",
+              headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+              }
+            }),
+            catch: (e) => new NetworkError({
+              message: `Failed to connect to ${serverUrl}`,
+              cause: e
+            })
+          }),
+          Effect2.flatMap(
+            (response) => pipe2(
+              Effect2.tryPromise({
+                try: () => response.json(),
+                catch: () => new NetworkError({ message: "Failed to parse API response" })
+              }),
+              Effect2.flatMap((json) => parseScopeOptionsResponse(response, json))
+            )
+          )
+        );
+      })
+    );
+    buildRuleOptionsUrl = (serverUrl, options) => {
+      const url = buildApiUrl(serverUrl, "/api/skills/rule-options");
+      if (options.orgId) {
+        url.searchParams.set("orgId", options.orgId);
+      }
+      if (options.orgProjects && options.orgProjects.length > 0) {
+        url.searchParams.set("orgProjects", options.orgProjects.join(","));
+      }
+      if (options.personalProjects && options.personalProjects.length > 0) {
+        url.searchParams.set(
+          "personalProjects",
+          options.personalProjects.join(",")
+        );
+      }
+      if (options.includeUserGlobal !== void 0) {
+        url.searchParams.set(
+          "includeUserGlobal",
+          String(options.includeUserGlobal)
+        );
+      }
+      if (options.includeOrgGlobal !== void 0) {
+        url.searchParams.set("includeOrgGlobal", String(options.includeOrgGlobal));
+      }
+      return url;
+    };
+    fetchRuleOptions = (options = {}) => pipe2(
+      Effect2.all({
+        apiKey: resolveApiKey(options.apiKey),
+        serverUrl: resolveServerUrl(options.serverUrl)
+      }),
+      Effect2.flatMap(
+        ({ apiKey, serverUrl }) => pipe2(
+          Effect2.tryPromise({
+            try: () => fetch(buildRuleOptionsUrl(serverUrl, options).toString(), {
+              method: "GET",
+              headers: {
+                Authorization: `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+              }
+            }),
+            catch: (e) => new NetworkError({
+              message: `Failed to connect to ${serverUrl}`,
+              cause: e
+            })
+          }),
+          Effect2.flatMap(
+            (response) => pipe2(
+              Effect2.tryPromise({
+                try: () => response.json(),
+                catch: () => new NetworkError({ message: "Failed to parse API response" })
+              }),
+              Effect2.flatMap((json) => {
+                if (!response.ok) {
+                  return parseResponse(response, json).pipe(
+                    Effect2.flatMap(
+                      () => Effect2.fail(
+                        new ApiError({
+                          message: "API request failed",
+                          code: "UNKNOWN_ERROR",
+                          status: response.status
+                        })
+                      )
+                    )
+                  );
+                }
+                return Effect2.succeed(json);
+              })
+            )
+          )
+        )
+      )
+    );
+    fetchSkills = (options) => pipe2(
+      Effect2.all({
+        apiKey: resolveApiKey(options.apiKey),
+        serverUrl: resolveServerUrl(options.serverUrl)
+      }),
+      Effect2.flatMap(({ apiKey, serverUrl }) => {
+        const url = buildExportUrl(serverUrl, options);
+        return executeApiRequest(url, apiKey, serverUrl);
+      })
+    );
+    validateApiKey = (apiKey, serverUrl) => pipe2(
+      Effect2.tryPromise({
+        try: async () => {
+          const baseUrl = serverUrl ?? "https://braid.cloud";
+          const url = buildApiUrl(baseUrl, "/api/skills/export");
+          url.searchParams.set("profile", "default");
+          const response = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+              Authorization: `Bearer ${apiKey}`,
+              "Content-Type": "application/json"
+            }
+          });
+          return response.status !== 401;
+        },
+        catch: (e) => new NetworkError({
+          message: `Failed to connect to ${serverUrl ?? "https://braid.cloud"}`,
+          cause: e
         })
-      );
-    }
-    return Effect2.fail(
-      new ApiError({
-        message: errorResponse.error || "API request failed",
-        code: errorResponse.code || "UNKNOWN_ERROR",
-        status: response.status
       })
     );
+    fetchSkillsAsync = (options) => Effect2.runPromise(fetchSkills(options));
+    validateApiKeyAsync = (apiKey, serverUrl) => Effect2.runPromise(validateApiKey(apiKey, serverUrl));
+    fetchScopeOptionsAsync = (options = {}) => Effect2.runPromise(fetchScopeOptions(options));
+    fetchRuleOptionsAsync = (options = {}) => Effect2.runPromise(fetchRuleOptions(options));
   }
-  return Effect2.succeed(json);
-};
-var buildApiUrl = (serverUrl, path2) => {
-  const baseUrl = serverUrl.replace(TRAILING_SLASH_REGEX, "");
-  return new URL(`${baseUrl}${path2}`);
-};
-var buildExportUrl = (serverUrl, options) => {
-  const url = buildApiUrl(serverUrl, "/api/skills/export");
-  if (options.profile) {
-    url.searchParams.set("profile", options.profile);
-  }
-  if (options.orgProjects && options.orgProjects.length > 0) {
-    url.searchParams.set("orgProjects", options.orgProjects.join(","));
-  }
-  if (options.personalProjects && options.personalProjects.length > 0) {
-    url.searchParams.set(
-      "personalProjects",
-      options.personalProjects.join(",")
-    );
+});
+
+// src/lib/tui.ts
+import process3 from "process";
+import {
+  cancel as clackCancel,
+  confirm as clackConfirm,
+  group as clackGroup,
+  groupMultiselect as clackGroupMultiselect,
+  intro as clackIntro,
+  isCancel as clackIsCancel,
+  log as clackLog,
+  multiselect as clackMultiselect,
+  note as clackNote,
+  outro as clackOutro,
+  password as clackPassword,
+  select as clackSelect,
+  selectKey as clackSelectKey,
+  spinner as clackSpinner,
+  text as clackText
+} from "@clack/prompts";
+function spinner() {
+  if (isTTY) {
+    return clackSpinner();
   }
-  if (options.includeUserGlobal !== void 0) {
-    url.searchParams.set(
-      "includeUserGlobal",
-      String(options.includeUserGlobal)
-    );
+  return {
+    start: (message) => {
+      if (message) {
+        process3.stdout.write(`${message}
+`);
+      }
+    },
+    stop: (message) => {
+      if (message) {
+        process3.stdout.write(`${message}
+`);
+      }
+    },
+    message: (message) => {
+      if (message) {
+        process3.stdout.write(`${message}
+`);
+      }
+    }
+  };
+}
+function intro(message) {
+  if (isTTY) {
+    clackIntro(message);
+  } else {
+    process3.stdout.write(`
+${message}
+`);
   }
-  if (options.includeOrgGlobal !== void 0) {
-    url.searchParams.set("includeOrgGlobal", String(options.includeOrgGlobal));
+}
+function outro(message) {
+  if (isTTY) {
+    clackOutro(message);
+  } else {
+    process3.stdout.write(`${message}
+
+`);
   }
-  return url;
-};
-var executeApiRequest = (url, apiKey, serverUrl) => pipe2(
-  Effect2.tryPromise({
-    try: () => fetch(url.toString(), {
-      method: "GET",
-      headers: {
-        Authorization: `Bearer ${apiKey}`,
-        "Content-Type": "application/json"
+}
+var isTTY, cancel, confirm, isCancel, log, multiselect, password, select, text;
+var init_tui = __esm({
+  "src/lib/tui.ts"() {
+    "use strict";
+    init_esm_shims();
+    isTTY = Boolean(process3.stdout.isTTY);
+    cancel = clackCancel;
+    confirm = clackConfirm;
+    isCancel = clackIsCancel;
+    log = clackLog;
+    multiselect = clackMultiselect;
+    password = clackPassword;
+    select = clackSelect;
+    text = clackText;
+  }
+});
+
+// src/lib/scope-args.ts
+function parseProjectIds(input) {
+  return input.split(",").map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function inferScopeSource(flags) {
+  if (flags.profile) {
+    return "profile";
+  }
+  if (flags.projects || flags.ruleIds || flags.excludedRuleIds) {
+    return "manual";
+  }
+  return void 0;
+}
+function buildManualSelection(flags) {
+  const projectIds = parseProjectIds(flags.projects ?? "");
+  const ruleIds = parseProjectIds(flags.ruleIds ?? "");
+  const excludedRuleIds = parseProjectIds(flags.excludedRuleIds ?? "");
+  return {
+    organization: flags.organization,
+    source: "manual",
+    ...projectIds.length > 0 ? { projectIds } : {},
+    ...ruleIds.length > 0 ? { ruleIds } : {},
+    ...excludedRuleIds.length > 0 ? { excludedRuleIds } : {},
+    includeUserGlobal: flags.includeUserGlobal ?? flags.organization === "personal",
+    includeOrgGlobal: flags.includeOrgGlobal ?? flags.organization === "organization"
+  };
+}
+function resolveSelectionFromFlags(flags) {
+  if (!flags.organization) {
+    return null;
+  }
+  const source = flags.source ?? inferScopeSource(flags);
+  if (!source) {
+    return null;
+  }
+  if (source === "profile") {
+    const profile = flags.profile?.trim();
+    if (!profile) {
+      return null;
+    }
+    return { organization: flags.organization, source, profile };
+  }
+  return buildManualSelection(flags);
+}
+var init_scope_args = __esm({
+  "src/lib/scope-args.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/lib/scope-config.ts
+function buildManualScopeConfig(base, selection) {
+  let projectScope = {};
+  if (selection.projectIds && selection.projectIds.length > 0) {
+    projectScope = selection.organization === "organization" ? { orgProjects: selection.projectIds } : { personalProjects: selection.projectIds };
+  }
+  return {
+    ...base,
+    ...projectScope,
+    ...selection.ruleIds && selection.ruleIds.length > 0 ? { ruleIds: selection.ruleIds } : {},
+    ...selection.excludedRuleIds && selection.excludedRuleIds.length > 0 ? { excludedRuleIds: selection.excludedRuleIds } : {},
+    includeUserGlobal: selection.includeUserGlobal ?? selection.organization === "personal",
+    includeOrgGlobal: selection.includeOrgGlobal ?? selection.organization === "organization"
+  };
+}
+function buildScopedConfig(existing, selection) {
+  const {
+    profile: _oldProfile,
+    orgProjects: _oldOrgProjects,
+    personalProjects: _oldPersonalProjects,
+    ...base
+  } = existing;
+  if (selection.source === "profile") {
+    const profile = selection.profile?.trim();
+    return {
+      ...base,
+      ...profile ? { profile } : {},
+      includeUserGlobal: selection.organization === "personal",
+      includeOrgGlobal: selection.organization === "organization"
+    };
+  }
+  if (selection.source === "manual") {
+    return buildManualScopeConfig(base, selection);
+  }
+  return base;
+}
+var init_scope_config = __esm({
+  "src/lib/scope-config.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/commands/scope.ts
+var scope_exports = {};
+__export(scope_exports, {
+  scopeCommand: () => scopeCommand
+});
+import process4 from "process";
+function exitCancelled(message) {
+  cancel(message);
+  process4.exit(0);
+}
+async function selectTargetFile(options) {
+  if (options.file) {
+    return options.file;
+  }
+  const target = await select({
+    message: "Where should this scope be saved?",
+    options: [
+      {
+        value: "user",
+        label: "braid.user.json",
+        hint: "Personal machine defaults"
+      },
+      {
+        value: "project",
+        label: "braid.json",
+        hint: "Shared project defaults"
       }
-    }),
-    catch: (e) => new NetworkError({
-      message: `Failed to connect to ${serverUrl}`,
-      cause: e
-    })
-  }),
-  Effect2.flatMap(
-    (response) => pipe2(
-      Effect2.tryPromise({
-        try: () => response.json(),
-        catch: () => new NetworkError({ message: "Failed to parse API response" })
-      }),
-      Effect2.flatMap((json) => parseResponse(response, json))
+    ],
+    initialValue: "user"
+  });
+  if (isCancel(target)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  return target;
+}
+async function selectOrganization(scopeOptions) {
+  const options = [
+    { value: "personal", label: "Personal", hint: "Your personal rules" }
+  ];
+  for (const org of scopeOptions.organizations.filter(
+    (item) => !item.isPersonal
+  )) {
+    options.push({ value: `org:${org.id}`, label: org.name, hint: org.id });
+  }
+  const selected = await select({
+    message: "Select organization context:",
+    options,
+    initialValue: "personal"
+  });
+  if (isCancel(selected)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  if (selected === "personal") {
+    return { organization: "personal" };
+  }
+  return { organization: "organization", orgId: selected.replace("org:", "") };
+}
+async function selectScopeSource() {
+  const source = await select({
+    message: "Select scope source:",
+    options: [
+      { value: "profile", label: "Profile", hint: "Use an MCP profile" },
+      {
+        value: "manual",
+        label: "Manual",
+        hint: "Mix globals, projects, and rules"
+      }
+    ],
+    initialValue: "profile"
+  });
+  if (isCancel(source)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  return source;
+}
+async function selectProfileName(scopeOptions) {
+  if (scopeOptions.profiles.length === 0) {
+    const profileName = await text({
+      message: "Profile name:",
+      placeholder: "default",
+      validate: (value) => (value ?? "").trim().length > 0 ? void 0 : "Profile name is required"
+    });
+    if (isCancel(profileName)) {
+      exitCancelled("Scope update cancelled.");
+    }
+    return profileName.trim();
+  }
+  const profile = await select({
+    message: "Select profile:",
+    options: scopeOptions.profiles.map((p) => ({
+      value: p.name,
+      label: p.name,
+      hint: p.id
+    })),
+    ...scopeOptions.profiles[0]?.name ? { initialValue: scopeOptions.profiles[0].name } : {}
+  });
+  if (isCancel(profile)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  return profile;
+}
+function projectsForContext(organizationContext, scopeOptions) {
+  if (organizationContext.organization === "personal") {
+    return scopeOptions.personalProjects;
+  }
+  const orgProjects = scopeOptions.orgProjects.find(
+    (o) => o.orgId === organizationContext.orgId
+  );
+  return orgProjects?.projects ?? [];
+}
+async function selectProjects(organizationContext, scopeOptions) {
+  const availableProjects = projectsForContext(
+    organizationContext,
+    scopeOptions
+  );
+  if (availableProjects.length === 0) {
+    return void 0;
+  }
+  const shouldUseProjects = await confirm({
+    message: "Include project rules too?",
+    initialValue: true
+  });
+  if (isCancel(shouldUseProjects)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  if (!shouldUseProjects) {
+    return void 0;
+  }
+  const selected = await multiselect({
+    message: "Select projects:",
+    options: availableProjects.map((p) => ({
+      value: p.id,
+      label: p.name,
+      hint: p.id
+    })),
+    required: false
+  });
+  if (isCancel(selected)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  return selected.length > 0 ? selected : void 0;
+}
+async function pickRuleIds(message, rules) {
+  const selected = await multiselect({
+    message,
+    options: rules.map((rule) => ({
+      value: rule.id,
+      label: rule.title,
+      hint: rule.id
+    })),
+    required: false
+  });
+  if (isCancel(selected)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  return selected.length > 0 ? selected : void 0;
+}
+function manualInputsFromFlag(flagSelection) {
+  return {
+    includeUserGlobal: flagSelection.includeUserGlobal,
+    includeOrgGlobal: flagSelection.includeOrgGlobal,
+    ...flagSelection.projectIds ? { projectIds: flagSelection.projectIds } : {},
+    ...flagSelection.ruleIds ? { ruleIds: flagSelection.ruleIds } : {},
+    ...flagSelection.excludedRuleIds ? { excludedRuleIds: flagSelection.excludedRuleIds } : {}
+  };
+}
+async function promptRuleFilters(organizationContext, projectIds, includeUserGlobal, includeOrgGlobal, serverUrl, apiKey) {
+  const filterMode = await select({
+    message: "Rule filtering:",
+    options: [
+      { value: "none", label: "None", hint: "Use all matched rules" },
+      {
+        value: "include",
+        label: "Only include",
+        hint: "Pick explicit rule IDs"
+      },
+      { value: "exclude", label: "Exclude", hint: "Remove specific rule IDs" },
+      { value: "both", label: "Include + exclude", hint: "Both filters" }
+    ],
+    initialValue: "none"
+  });
+  if (isCancel(filterMode) || filterMode === "none") {
+    if (isCancel(filterMode)) {
+      exitCancelled("Scope update cancelled.");
+    }
+    return {};
+  }
+  const ruleOptions = await fetchRuleOptionsAsync(
+    buildRuleOptionsRequest(
+      organizationContext,
+      projectIds,
+      includeUserGlobal,
+      includeOrgGlobal,
+      serverUrl,
+      apiKey
     )
-  )
-);
-var fetchSkills = (options) => pipe2(
-  Effect2.all({
-    apiKey: resolveApiKey(options.apiKey),
-    serverUrl: resolveServerUrl(options.serverUrl)
-  }),
-  Effect2.flatMap(({ apiKey, serverUrl }) => {
-    const url = buildExportUrl(serverUrl, options);
-    return executeApiRequest(url, apiKey, serverUrl);
-  })
-);
-var validateApiKey = (apiKey, serverUrl) => pipe2(
-  Effect2.tryPromise({
-    try: async () => {
-      const baseUrl = serverUrl ?? "https://braid.cloud";
-      const url = buildApiUrl(baseUrl, "/api/skills/export");
-      url.searchParams.set("profile", "default");
-      const response = await fetch(url.toString(), {
-        method: "GET",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "Content-Type": "application/json"
-        }
-      });
-      return response.status !== 401;
-    },
-    catch: (e) => new NetworkError({
-      message: `Failed to connect to ${serverUrl ?? "https://braid.cloud"}`,
-      cause: e
-    })
-  })
-);
-var fetchSkillsAsync = (options) => Effect2.runPromise(fetchSkills(options));
-var validateApiKeyAsync = (apiKey, serverUrl) => Effect2.runPromise(validateApiKey(apiKey, serverUrl));
+  );
+  const ruleIds = filterMode === "include" || filterMode === "both" ? await pickRuleIds("Select rules to include:", ruleOptions.rules) : void 0;
+  const excludedRuleIds = filterMode === "exclude" || filterMode === "both" ? await pickRuleIds("Select rules to exclude:", ruleOptions.rules) : void 0;
+  return {
+    ...ruleIds ? { ruleIds } : {},
+    ...excludedRuleIds ? { excludedRuleIds } : {}
+  };
+}
+function buildRuleOptionsRequest(organizationContext, projectIds, includeUserGlobal, includeOrgGlobal, serverUrl, apiKey) {
+  let projectScope = {};
+  if (projectIds && organizationContext.organization === "organization") {
+    projectScope = { orgProjects: projectIds };
+  }
+  if (projectIds && organizationContext.organization === "personal") {
+    projectScope = { personalProjects: projectIds };
+  }
+  return {
+    serverUrl,
+    ...apiKey ? { apiKey } : {},
+    ...organizationContext.organization === "organization" ? { orgId: organizationContext.orgId } : {},
+    ...projectScope,
+    includeUserGlobal,
+    includeOrgGlobal
+  };
+}
+async function resolveManualInputs(organizationContext, scopeOptions, serverUrl, apiKey) {
+  const { includeUserGlobal, includeOrgGlobal } = await promptGlobalInclusions(organizationContext);
+  const projectIds = await selectProjects(organizationContext, scopeOptions);
+  const filters = await promptRuleFilters(
+    organizationContext,
+    projectIds,
+    includeUserGlobal,
+    includeOrgGlobal,
+    serverUrl,
+    apiKey
+  );
+  return {
+    includeUserGlobal,
+    includeOrgGlobal,
+    ...projectIds ? { projectIds } : {},
+    ...filters
+  };
+}
+async function promptGlobalInclusions(organizationContext) {
+  const includeUserGlobal = await confirm({
+    message: "Include personal global rules?",
+    initialValue: organizationContext.organization === "personal"
+  });
+  if (isCancel(includeUserGlobal)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  if (organizationContext.organization === "personal") {
+    return { includeUserGlobal, includeOrgGlobal: false };
+  }
+  const includeOrgGlobal = await confirm({
+    message: "Include organization global rules?",
+    initialValue: true
+  });
+  if (isCancel(includeOrgGlobal)) {
+    exitCancelled("Scope update cancelled.");
+  }
+  return { includeUserGlobal, includeOrgGlobal };
+}
+async function resolveManualSelection(source, flagSelection, organizationContext, scopeOptions, serverUrl, apiKey) {
+  if (source !== "manual") {
+    return void 0;
+  }
+  if (flagSelection?.source === "manual") {
+    return manualInputsFromFlag(flagSelection);
+  }
+  return await resolveManualInputs(
+    organizationContext,
+    scopeOptions,
+    serverUrl,
+    apiKey
+  );
+}
+async function resolveOrganizationContext(flagSelection, scopeOptions) {
+  if (flagSelection?.organization === "personal") {
+    return { organization: "personal" };
+  }
+  return await selectOrganization(scopeOptions);
+}
+async function resolveProfileSelection(source, flagSelection, scopeOptions) {
+  if (source !== "profile") {
+    return void 0;
+  }
+  if (flagSelection?.source === "profile") {
+    return flagSelection.profile;
+  }
+  return await selectProfileName(scopeOptions);
+}
+function resolveFlagSelection(options) {
+  const flags = {
+    ...options.organization ? { organization: options.organization } : {},
+    ...options.source ? { source: options.source } : {},
+    ...options.profile ? { profile: options.profile } : {},
+    ...options.projects ? { projects: options.projects } : {},
+    ...options.ruleIds ? { ruleIds: options.ruleIds } : {},
+    ...options.excludedRuleIds ? { excludedRuleIds: options.excludedRuleIds } : {},
+    ...options.includeUserGlobal !== void 0 ? { includeUserGlobal: options.includeUserGlobal } : {},
+    ...options.includeOrgGlobal !== void 0 ? { includeOrgGlobal: options.includeOrgGlobal } : {}
+  };
+  return resolveSelectionFromFlags(flags);
+}
+async function scopeCommand(options) {
+  intro("braid scope");
+  const config = await loadMergedConfigAsync();
+  const targetFile = await selectTargetFile(options);
+  const loadSpinner = spinner();
+  loadSpinner.start("Loading scope options from braid...");
+  try {
+    const serverUrl = options.server ?? config.serverUrl;
+    const apiKey = options.apiKey ?? config.token;
+    const scopeOptions = await fetchScopeOptionsAsync({
+      serverUrl,
+      ...apiKey ? { apiKey } : {}
+    });
+    loadSpinner.stop("Scope options loaded");
+    const flagSelection = resolveFlagSelection(options);
+    const organizationContext = await resolveOrganizationContext(
+      flagSelection,
+      scopeOptions
+    );
+    const source = flagSelection?.source ?? await selectScopeSource();
+    const profile = await resolveProfileSelection(
+      source,
+      flagSelection,
+      scopeOptions
+    );
+    const manualInputs = await resolveManualSelection(
+      source,
+      flagSelection,
+      organizationContext,
+      scopeOptions,
+      serverUrl,
+      apiKey
+    );
+    const selection = {
+      organization: organizationContext.organization,
+      source,
+      ...profile ? { profile } : {},
+      ...manualInputs ?? {}
+    };
+    if (targetFile === "user") {
+      const existing2 = await loadUserConfigAsync() ?? {};
+      const path3 = await saveUserConfigAsync(
+        buildScopedConfig(existing2, selection)
+      );
+      outro(`Updated ${path3}`);
+      return;
+    }
+    const existing = await loadProjectConfigAsync() ?? {};
+    const path2 = await saveProjectConfigAsync(
+      buildScopedConfig(existing, selection)
+    );
+    outro(`Updated ${path2}`);
+  } catch (error) {
+    loadSpinner.stop("Failed to load scope options");
+    log.error(error instanceof Error ? error.message : String(error));
+    process4.exit(1);
+  }
+}
+var init_scope = __esm({
+  "src/commands/scope.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_api();
+    init_config();
+    init_scope_args();
+    init_scope_config();
+    init_tui();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+import { createRequire } from "module";
+import { Command } from "commander";
 
 // src/commands/auth.ts
+init_esm_shims();
+init_api();
 init_config();
+init_tui();
+import process5 from "process";
+async function configureDefaultScopeAsync(serverUrl) {
+  const shouldConfigureScope = await confirm({
+    message: "Configure organization and scope defaults now?",
+    initialValue: true
+  });
+  if (isCancel(shouldConfigureScope) || !shouldConfigureScope) {
+    return;
+  }
+  const { scopeCommand: scopeCommand2 } = await Promise.resolve().then(() => (init_scope(), scope_exports));
+  const config = await loadMergedConfigAsync();
+  await scopeCommand2({
+    file: "user",
+    server: serverUrl,
+    ...config.token ? { apiKey: config.token } : {}
+  });
+}
 async function authCommand(options) {
   intro("braid auth");
   const config = await loadMergedConfigAsync();
@@ -448,7 +1192,7 @@ async function authCommand(options) {
     }
   }
   const apiKey = await password({
-    message: "Enter your Braid API key:",
+    message: "Enter your braid API key:",
     validate: (value) => {
       if (!value) {
         return "API key is required";
@@ -461,35 +1205,48 @@ async function authCommand(options) {
   });
   if (isCancel(apiKey)) {
     cancel("Auth cancelled.");
-    process3.exit(0);
+    process5.exit(0);
   }
   const authSpinner = spinner();
+  let authSpinnerActive = true;
+  const stopAuthSpinner = (message) => {
+    if (!authSpinnerActive) {
+      return;
+    }
+    authSpinner.stop(message);
+    authSpinnerActive = false;
+  };
   authSpinner.start("Validating API key...");
   try {
     const serverUrl = options.server ?? "https://braid.cloud";
     const isValid = await validateApiKeyAsync(apiKey, serverUrl);
     if (!isValid) {
-      authSpinner.stop("Invalid API key");
+      stopAuthSpinner("Invalid API key");
       log.error(
         "The API key could not be validated. Please check your key and try again."
       );
-      process3.exit(1);
+      process5.exit(1);
     }
     await setApiKeyAsync(apiKey);
-    authSpinner.stop("API key validated and saved");
+    const existingUserConfig = await loadUserConfigAsync();
+    if (existingUserConfig?.token) {
+      await saveUserConfigAsync({ ...existingUserConfig, token: apiKey });
+    }
+    stopAuthSpinner("API key validated and saved");
+    await configureDefaultScopeAsync(serverUrl);
     log.success(`Config saved to ${CONFIG_FILE}`);
     outro(
       "You're authenticated! Run 'braid install --profile <name>' to install skills."
     );
   } catch (error) {
-    authSpinner.stop("Validation failed");
+    stopAuthSpinner("Validation failed");
     const message = error instanceof Error ? error.message : String(error);
     log.error(`Failed to validate API key: ${message}`);
-    process3.exit(1);
+    process5.exit(1);
   }
 }
 async function displayTokenSource(masked) {
-  if (process3.env.BRAID_API_KEY) {
+  if (process5.env.BRAID_API_KEY) {
     log.info(`Authenticated with key: ${masked}`);
     log.info("Source: BRAID_API_KEY environment variable");
     return;
@@ -552,42 +1309,114 @@ init_esm_shims();
 import { access, constants } from "fs/promises";
 import { homedir as homedir2 } from "os";
 import { join as join2 } from "path";
-import process4 from "process";
+import process6 from "process";
 import { Effect as Effect3, pipe as pipe3 } from "effect";
 var home = homedir2();
+var vscodeExtSettingsPath = (extensionId, filename) => {
+  if (process6.platform === "darwin") {
+    return join2(
+      home,
+      "Library",
+      "Application Support",
+      "Code",
+      "User",
+      "globalStorage",
+      extensionId,
+      "settings",
+      filename
+    );
+  }
+  if (process6.platform === "win32") {
+    const appData = process6.env.APPDATA ?? join2(home, "AppData", "Roaming");
+    return join2(
+      appData,
+      "Code",
+      "User",
+      "globalStorage",
+      extensionId,
+      "settings",
+      filename
+    );
+  }
+  return join2(
+    home,
+    ".config",
+    "Code",
+    "User",
+    "globalStorage",
+    extensionId,
+    "settings",
+    filename
+  );
+};
+var claudeDesktopConfigPath = () => {
+  if (process6.platform === "darwin") {
+    return join2(
+      home,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  }
+  if (process6.platform === "win32") {
+    const appData = process6.env.APPDATA ?? join2(home, "AppData", "Roaming");
+    return join2(appData, "Claude", "claude_desktop_config.json");
+  }
+  return join2(home, ".config", "Claude", "claude_desktop_config.json");
+};
 var AGENTS = [
   {
     id: "amp",
-    name: "Amp, Kimi Code CLI",
+    name: "Amp",
     projectPath: ".agents/skills",
-    globalPath: join2(home, ".config", "agents", "skills")
+    globalPath: join2(home, ".config", "agents", "skills"),
+    mcpProjectConfigPath: ".amp/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".amp", "mcp.json")
   },
   {
     id: "kimi-cli",
     name: "Kimi Code CLI",
     projectPath: ".agents/skills",
-    globalPath: join2(home, ".config", "agents", "skills")
+    globalPath: join2(home, ".config", "agents", "skills"),
+    mcpProjectConfigPath: ".agents/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".config", "agents", "mcp.json")
   },
   {
     id: "antigravity",
     name: "Antigravity",
     projectPath: ".agent/skills",
-    globalPath: join2(home, ".gemini", "antigravity", "global_skills")
+    globalPath: join2(home, ".gemini", "antigravity", "global_skills"),
+    mcpProjectConfigPath: ".agent/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".gemini", "antigravity", "mcp.json")
   },
   {
     id: "claude-code",
     name: "Claude Code",
     projectPath: ".claude/skills",
     globalPath: join2(home, ".claude", "skills"),
+    projectMarkerPath: ".claude",
+    globalMarkerPath: join2(home, ".claude"),
     rulesProjectPath: ".claude/rules",
     rulesGlobalPath: join2(home, ".claude", "rules"),
-    ruleFormat: "markdown-dir"
+    ruleFormat: "markdown-dir",
+    mcpProjectConfigPath: ".mcp.json",
+    mcpEntryStyle: "typed-stdio"
+  },
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    projectPath: "",
+    globalPath: "",
+    mcpGlobalConfigPath: claudeDesktopConfigPath()
   },
   {
     id: "moltbot",
     name: "Moltbot",
     projectPath: "skills",
-    globalPath: join2(home, ".moltbot", "skills")
+    globalPath: join2(home, ".moltbot", "skills"),
+    mcpProjectConfigPath: "mcp.json",
+    mcpGlobalConfigPath: join2(home, ".moltbot", "mcp.json")
   },
   {
     id: "cline",
@@ -595,37 +1424,52 @@ var AGENTS = [
     projectPath: ".cline/skills",
     globalPath: join2(home, ".cline", "skills"),
     rulesProjectPath: ".clinerules",
-    ruleFormat: "append-single"
+    ruleFormat: "append-single",
+    mcpGlobalConfigPath: vscodeExtSettingsPath(
+      "saoudrizwan.claude-dev",
+      "cline_mcp_settings.json"
+    ),
+    mcpEntryStyle: "cline"
   },
   {
     id: "codebuddy",
     name: "CodeBuddy",
     projectPath: ".codebuddy/skills",
-    globalPath: join2(home, ".codebuddy", "skills")
+    globalPath: join2(home, ".codebuddy", "skills"),
+    mcpProjectConfigPath: ".codebuddy/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".codebuddy", "mcp.json")
   },
   {
     id: "codex",
     name: "Codex",
     projectPath: ".codex/skills",
-    globalPath: join2(home, ".codex", "skills")
+    globalPath: join2(home, ".codex", "skills"),
+    mcpProjectConfigPath: ".codex/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".codex", "mcp.json")
   },
   {
     id: "command-code",
     name: "Command Code",
     projectPath: ".commandcode/skills",
-    globalPath: join2(home, ".commandcode", "skills")
+    globalPath: join2(home, ".commandcode", "skills"),
+    mcpProjectConfigPath: ".commandcode/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".commandcode", "mcp.json")
   },
   {
     id: "continue",
     name: "Continue",
     projectPath: ".continue/skills",
-    globalPath: join2(home, ".continue", "skills")
+    globalPath: join2(home, ".continue", "skills"),
+    mcpProjectConfigPath: ".continue/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".continue", "mcp.json")
   },
   {
     id: "crush",
     name: "Crush",
     projectPath: ".crush/skills",
-    globalPath: join2(home, ".config", "crush", "skills")
+    globalPath: join2(home, ".config", "crush", "skills"),
+    mcpProjectConfigPath: ".crush/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".config", "crush", "mcp.json")
   },
   {
     id: "cursor",
@@ -633,19 +1477,25 @@ var AGENTS = [
     projectPath: ".cursor/skills",
     globalPath: join2(home, ".cursor", "skills"),
     rulesProjectPath: ".cursor/rules",
-    ruleFormat: "mdc"
+    ruleFormat: "mdc",
+    mcpProjectConfigPath: ".cursor/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".cursor", "mcp.json")
   },
   {
     id: "droid",
     name: "Droid",
     projectPath: ".factory/skills",
-    globalPath: join2(home, ".factory", "skills")
+    globalPath: join2(home, ".factory", "skills"),
+    mcpProjectConfigPath: ".factory/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".factory", "mcp.json")
   },
   {
     id: "gemini-cli",
     name: "Gemini CLI",
     projectPath: ".gemini/skills",
-    globalPath: join2(home, ".gemini", "skills")
+    globalPath: join2(home, ".gemini", "skills"),
+    mcpProjectConfigPath: ".gemini/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".gemini", "mcp.json")
   },
   {
     id: "github-copilot",
@@ -653,79 +1503,108 @@ var AGENTS = [
     projectPath: ".github/skills",
     globalPath: join2(home, ".copilot", "skills"),
     rulesProjectPath: ".github/copilot-instructions.md",
-    ruleFormat: "append-single"
+    ruleFormat: "append-single",
+    mcpProjectConfigPath: ".vscode/mcp.json",
+    mcpRootKey: "servers",
+    mcpEntryStyle: "typed-stdio"
   },
   {
     id: "goose",
     name: "Goose",
     projectPath: ".goose/skills",
-    globalPath: join2(home, ".config", "goose", "skills")
+    globalPath: join2(home, ".config", "goose", "skills"),
+    mcpGlobalConfigPath: join2(home, ".config", "goose", "mcp.json")
   },
   {
     id: "junie",
     name: "Junie",
     projectPath: ".junie/skills",
-    globalPath: join2(home, ".junie", "skills")
+    globalPath: join2(home, ".junie", "skills"),
+    mcpProjectConfigPath: ".junie/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".junie", "mcp.json")
   },
   {
     id: "kilo",
     name: "Kilo Code",
     projectPath: ".kilocode/skills",
-    globalPath: join2(home, ".kilocode", "skills")
+    globalPath: join2(home, ".kilocode", "skills"),
+    mcpGlobalConfigPath: vscodeExtSettingsPath(
+      "kilocode.kilo-code",
+      "mcp_settings.json"
+    ),
+    mcpEntryStyle: "cline"
   },
   {
     id: "kiro-cli",
     name: "Kiro CLI",
     projectPath: ".kiro/skills",
-    globalPath: join2(home, ".kiro", "skills")
+    globalPath: join2(home, ".kiro", "skills"),
+    mcpProjectConfigPath: ".kiro/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".kiro", "mcp.json")
   },
   {
     id: "kode",
     name: "Kode",
     projectPath: ".kode/skills",
-    globalPath: join2(home, ".kode", "skills")
+    globalPath: join2(home, ".kode", "skills"),
+    mcpProjectConfigPath: ".kode/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".kode", "mcp.json")
   },
   {
     id: "mcpjam",
     name: "MCPJam",
     projectPath: ".mcpjam/skills",
-    globalPath: join2(home, ".mcpjam", "skills")
+    globalPath: join2(home, ".mcpjam", "skills"),
+    mcpProjectConfigPath: ".mcpjam/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".mcpjam", "mcp.json")
   },
   {
     id: "mux",
     name: "Mux",
     projectPath: ".mux/skills",
-    globalPath: join2(home, ".mux", "skills")
+    globalPath: join2(home, ".mux", "skills"),
+    mcpProjectConfigPath: ".mux/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".mux", "mcp.json")
   },
   {
     id: "opencode",
     name: "OpenCode",
     projectPath: ".opencode/skills",
-    globalPath: join2(home, ".config", "opencode", "skills")
+    globalPath: join2(home, ".config", "opencode", "skills"),
+    mcpProjectConfigPath: ".opencode/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".config", "opencode", "mcp.json")
   },
   {
     id: "openhands",
     name: "OpenHands",
     projectPath: ".openhands/skills",
-    globalPath: join2(home, ".openhands", "skills")
+    globalPath: join2(home, ".openhands", "skills"),
+    mcpProjectConfigPath: ".openhands/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".openhands", "mcp.json")
   },
   {
     id: "pi",
     name: "Pi",
     projectPath: ".pi/skills",
-    globalPath: join2(home, ".pi", "agent", "skills")
+    globalPath: join2(home, ".pi", "agent", "skills"),
+    mcpProjectConfigPath: ".pi/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".pi", "agent", "mcp.json")
   },
   {
     id: "qoder",
     name: "Qoder",
     projectPath: ".qoder/skills",
-    globalPath: join2(home, ".qoder", "skills")
+    globalPath: join2(home, ".qoder", "skills"),
+    mcpProjectConfigPath: ".qoder/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".qoder", "mcp.json")
   },
   {
     id: "qwen-code",
     name: "Qwen Code",
     projectPath: ".qwen/skills",
-    globalPath: join2(home, ".qwen", "skills")
+    globalPath: join2(home, ".qwen", "skills"),
+    mcpProjectConfigPath: ".qwen/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".qwen", "mcp.json")
   },
   {
     id: "roo",
@@ -734,13 +1613,20 @@ var AGENTS = [
     globalPath: join2(home, ".roo", "skills"),
     rulesProjectPath: ".roo/rules",
     rulesGlobalPath: join2(home, ".roo", "rules"),
-    ruleFormat: "markdown-dir"
+    ruleFormat: "markdown-dir",
+    mcpGlobalConfigPath: vscodeExtSettingsPath(
+      "rooveterinaryinc.roo-cline",
+      "mcp_settings.json"
+    ),
+    mcpEntryStyle: "cline"
   },
   {
     id: "trae",
     name: "Trae",
     projectPath: ".trae/skills",
-    globalPath: join2(home, ".trae", "skills")
+    globalPath: join2(home, ".trae", "skills"),
+    mcpProjectConfigPath: ".trae/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".trae", "mcp.json")
   },
   {
     id: "windsurf",
@@ -748,34 +1634,46 @@ var AGENTS = [
     projectPath: ".windsurf/skills",
     globalPath: join2(home, ".codeium", "windsurf", "skills"),
     rulesProjectPath: ".windsurfrules",
-    ruleFormat: "append-single"
+    ruleFormat: "append-single",
+    mcpGlobalConfigPath: join2(home, ".codeium", "windsurf", "mcp_config.json")
   },
   {
     id: "zencoder",
     name: "Zencoder",
     projectPath: ".zencoder/skills",
-    globalPath: join2(home, ".zencoder", "skills")
+    globalPath: join2(home, ".zencoder", "skills"),
+    mcpProjectConfigPath: ".zencoder/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".zencoder", "mcp.json")
   },
   {
     id: "neovate",
     name: "Neovate",
     projectPath: ".neovate/skills",
-    globalPath: join2(home, ".neovate", "skills")
+    globalPath: join2(home, ".neovate", "skills"),
+    mcpProjectConfigPath: ".neovate/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".neovate", "mcp.json")
   },
   {
     id: "pochi",
     name: "Pochi",
     projectPath: ".pochi/skills",
-    globalPath: join2(home, ".pochi", "skills")
+    globalPath: join2(home, ".pochi", "skills"),
+    mcpProjectConfigPath: ".pochi/mcp.json",
+    mcpGlobalConfigPath: join2(home, ".pochi", "mcp.json")
   },
   {
     id: "zed",
     name: "Zed",
     projectPath: "",
     globalPath: "",
+    projectMarkerPath: ".zed",
+    globalMarkerPath: join2(home, ".config", "zed"),
     rulesProjectPath: ".zed/rules",
     rulesGlobalPath: join2(home, ".config", "zed", "rules"),
-    ruleFormat: "markdown-dir"
+    ruleFormat: "markdown-dir",
+    mcpGlobalConfigPath: join2(home, ".config", "zed", "settings.json"),
+    mcpRootKey: "context_servers",
+    mcpEntryStyle: "zed"
   }
 ];
 var directoryExists = (path2) => pipe3(
@@ -787,7 +1685,7 @@ var directoryExists = (path2) => pipe3(
   Effect3.orElseSucceed(() => false)
 );
 var detectAgents = (projectRoot) => {
-  const cwd = projectRoot ?? process4.cwd();
+  const cwd = projectRoot ?? process6.cwd();
   return pipe3(
     Effect3.forEach(
       AGENTS,
@@ -795,6 +1693,8 @@ var detectAgents = (projectRoot) => {
         Effect3.all({
           hasProjectConfig: agent.projectPath ? directoryExists(join2(cwd, agent.projectPath)) : Effect3.succeed(false),
           hasGlobalConfig: agent.globalPath ? directoryExists(agent.globalPath) : Effect3.succeed(false),
+          hasProjectMarker: agent.projectMarkerPath ? directoryExists(join2(cwd, agent.projectMarkerPath)) : Effect3.succeed(false),
+          hasGlobalMarker: agent.globalMarkerPath ? directoryExists(agent.globalMarkerPath) : Effect3.succeed(false),
           hasRulesProjectConfig: agent.rulesProjectPath ? directoryExists(join2(cwd, agent.rulesProjectPath)) : Effect3.succeed(false),
           hasRulesGlobalConfig: agent.rulesGlobalPath ? directoryExists(agent.rulesGlobalPath) : Effect3.succeed(false)
         }),
@@ -802,12 +1702,14 @@ var detectAgents = (projectRoot) => {
           ({
             hasProjectConfig,
             hasGlobalConfig,
+            hasProjectMarker,
+            hasGlobalMarker,
             hasRulesProjectConfig,
             hasRulesGlobalConfig
           }) => ({
             ...agent,
-            hasProjectConfig: hasProjectConfig || hasRulesProjectConfig,
-            hasGlobalConfig: hasGlobalConfig || hasRulesGlobalConfig
+            hasProjectConfig: hasProjectConfig || hasRulesProjectConfig || hasProjectMarker,
+            hasGlobalConfig: hasGlobalConfig || hasRulesGlobalConfig || hasGlobalMarker
           })
         )
       ),
@@ -828,7 +1730,7 @@ var resolveInstallPath = (agent, options) => {
   if (!agent.projectPath) {
     return void 0;
   }
-  const cwd = options.projectRoot ?? process4.cwd();
+  const cwd = options.projectRoot ?? process6.cwd();
   return join2(cwd, agent.projectPath);
 };
 var resolveRulesInstallPath = (agent, options) => {
@@ -838,11 +1740,46 @@ var resolveRulesInstallPath = (agent, options) => {
   if (!agent.rulesProjectPath) {
     return void 0;
   }
-  const cwd = options.projectRoot ?? process4.cwd();
+  const cwd = options.projectRoot ?? process6.cwd();
   return join2(cwd, agent.rulesProjectPath);
 };
+var hasMcpConfig = (agent) => Boolean(agent.mcpProjectConfigPath) || Boolean(agent.mcpGlobalConfigPath);
+var resolveMcpConfigPath = (agent, options) => {
+  if (options.global) {
+    return agent.mcpGlobalConfigPath;
+  }
+  if (agent.mcpProjectConfigPath) {
+    const cwd = options.projectRoot ?? process6.cwd();
+    return join2(cwd, agent.mcpProjectConfigPath);
+  }
+  return agent.mcpGlobalConfigPath;
+};
+var buildMcpEntry = (style, env) => {
+  const command = "npx";
+  const args = ["-y", "@braid-cloud/mcp"];
+  const envObj = Object.keys(env).length > 0 ? env : void 0;
+  switch (style) {
+    case "standard":
+      return envObj ? { command, args, env: envObj } : { command, args };
+    case "typed-stdio":
+      return envObj ? { type: "stdio", command, args, env: envObj } : { type: "stdio", command, args };
+    case "zed":
+      return envObj ? { command: { path: command, args, env: envObj } } : { command: { path: command, args } };
+    case "cline":
+      return envObj ? { command, args, env: envObj, disabled: false } : { command, args, disabled: false };
+    default:
+      return envObj ? { command, args, env: envObj } : { command, args };
+  }
+};
+var detectMcpAgents = (projectRoot) => Effect3.runPromise(
+  pipe3(
+    detectAgents(projectRoot),
+    Effect3.map((detected) => detected.filter(hasMcpConfig))
+  )
+);
 
 // src/commands/install.ts
+init_api();
 init_config();
 
 // src/lib/metadata.ts
@@ -1208,77 +2145,8 @@ var writeSkills = (basePath, skills, agentId) => pipe6(
 );
 var writeSkillsAsync = (basePath, skills, agentId) => Effect6.runPromise(writeSkills(basePath, skills, agentId));
 
-// src/lib/tui.ts
-init_esm_shims();
-import process5 from "process";
-import {
-  cancel as clackCancel,
-  confirm as clackConfirm,
-  group as clackGroup,
-  groupMultiselect as clackGroupMultiselect,
-  intro as clackIntro,
-  isCancel as clackIsCancel,
-  log as clackLog,
-  multiselect as clackMultiselect,
-  note as clackNote,
-  outro as clackOutro,
-  password as clackPassword,
-  select as clackSelect,
-  selectKey as clackSelectKey,
-  spinner as clackSpinner,
-  text as clackText
-} from "@clack/prompts";
-var isTTY = Boolean(process5.stdout.isTTY);
-function spinner2() {
-  if (isTTY) {
-    return clackSpinner();
-  }
-  return {
-    start: (message) => {
-      if (message) {
-        process5.stdout.write(`${message}
-`);
-      }
-    },
-    stop: (message) => {
-      if (message) {
-        process5.stdout.write(`${message}
-`);
-      }
-    },
-    message: (message) => {
-      if (message) {
-        process5.stdout.write(`${message}
-`);
-      }
-    }
-  };
-}
-function intro2(message) {
-  if (isTTY) {
-    clackIntro(message);
-  } else {
-    process5.stdout.write(`
-${message}
-`);
-  }
-}
-function outro2(message) {
-  if (isTTY) {
-    clackOutro(message);
-  } else {
-    process5.stdout.write(`${message}
-
-`);
-  }
-}
-var cancel2 = clackCancel;
-var confirm2 = clackConfirm;
-var isCancel2 = clackIsCancel;
-var log2 = clackLog;
-var multiselect = clackMultiselect;
-
 // src/commands/install.ts
+init_tui();
 function resolveInstallConfig(options, config) {
   const orgProjectsFromFlag = options.orgProjects ? options.orgProjects.split(",").map((s) => s.trim()) : void 0;
   const personalProjectsFromFlag = options.personalProjects ? options.personalProjects.split(",").map((s) => s.trim()) : void 0;
@@ -1288,7 +2156,10 @@ function resolveInstallConfig(options, config) {
     includeUserGlobal: options.includeUserGlobals ?? config.includeUserGlobal,
     includeOrgGlobal: options.includeOrgGlobals ?? config.includeOrgGlobal,
     orgProjects: orgProjectsFromFlag ?? config.orgProjects,
-    personalProjects: personalProjectsFromFlag ?? config.personalProjects
+    personalProjects: personalProjectsFromFlag ?? config.personalProjects,
+    ruleIds: config.ruleIds,
+    excludedRuleIds: config.excludedRuleIds,
+    resolveOverlays: config.resolveOverlays
   };
 }
 function validateInstallOptions(resolved) {
@@ -1296,17 +2167,17 @@ function validateInstallOptions(resolved) {
   const hasOrgProjects = orgProjects && orgProjects.length > 0;
   const hasPersonalProjects = personalProjects && personalProjects.length > 0;
   if (!(profile || hasOrgProjects || hasPersonalProjects)) {
-    log2.error("No profile or project(s) specified.");
-    log2.info("Either:");
-    log2.info(
+    log.error("No profile or project(s) specified.");
+    log.info("Either:");
+    log.info(
       "  - Add 'profile', 'orgProjects', or 'personalProjects' to braid.json/braid.user.json"
     );
-    log2.info("  - Use --profile, --org-projects, or --personal-projects flags");
-    log2.info("");
-    log2.info("Examples:");
-    log2.info("  braid install --profile coding-standards");
-    log2.info("  braid install --org-projects proj123,proj456");
-    log2.info("  braid install --personal-projects myproj1");
+    log.info("  - Use --profile, --org-projects, or --personal-projects flags");
+    log.info("");
+    log.info("Examples:");
+    log.info("  braid install --profile coding-standards");
+    log.info("  braid install --org-projects proj123,proj456");
+    log.info("  braid install --personal-projects myproj1");
     process.exit(1);
   }
 }
@@ -1338,25 +2209,45 @@ function buildFetchOptions(resolved) {
   if (resolved.personalProjects && resolved.personalProjects.length > 0) {
     fetchOptions.personalProjects = resolved.personalProjects;
   }
+  if (resolved.ruleIds && resolved.ruleIds.length > 0) {
+    fetchOptions.ruleIds = resolved.ruleIds;
+  }
+  if (resolved.excludedRuleIds && resolved.excludedRuleIds.length > 0) {
+    fetchOptions.excludedRuleIds = resolved.excludedRuleIds;
+  }
+  if (resolved.resolveOverlays !== void 0) {
+    fetchOptions.resolveOverlays = resolved.resolveOverlays;
+  }
   return fetchOptions;
 }
 function displaySkillsAndExit(skills) {
-  log2.info("\nSkills:");
+  log.info("\nSkills:");
   for (const skill of skills) {
     const fileCount = skill.files.length;
-    log2.info(
+    log.info(
       `  ${skill.name} (${fileCount} file${fileCount !== 1 ? "s" : ""})`
     );
   }
   process.exit(0);
 }
+function getSelectableAgents(options) {
+  return AGENTS.filter(
+    (agent) => options.global ? Boolean(agent.globalPath) : Boolean(agent.projectPath)
+  ).map(
+    (agent) => ({
+      ...agent,
+      hasProjectConfig: false,
+      hasGlobalConfig: false
+    })
+  );
+}
 async function resolveAgents(options, installSpinner) {
   if (options.agents) {
     const agentIds = options.agents.split(",").map((s) => s.trim());
     const selectedAgents = agentIds.map((id) => {
       const agentConfig = getAgentById(id);
       if (!agentConfig) {
-        log2.warn(`Unknown agent: ${id}`);
+        log.warn(`Unknown agent: ${id}`);
         return null;
       }
       return {
@@ -1366,10 +2257,13 @@ async function resolveAgents(options, installSpinner) {
       };
     }).filter((a) => a !== null);
     if (selectedAgents.length === 0) {
-      log2.error("No valid agents specified.");
+      log.error("No valid agents specified.");
       process.exit(1);
     }
-    return selectedAgents;
+    return {
+      availableAgents: selectedAgents,
+      preselectedAgents: selectedAgents
+    };
   }
   installSpinner.start("Detecting installed agents...");
   const allDetectedAgents = await detectAgentsAsync();
@@ -1382,37 +2276,45 @@ async function resolveAgents(options, installSpinner) {
   );
   for (const agent of detectedAgents) {
     const targetPath = options.global ? agent.globalPath : agent.projectPath;
-    log2.info(`  ${agent.name} \u2192 ${targetPath}`);
+    log.info(`  ${agent.name} \u2192 ${targetPath}`);
   }
   if (detectedAgents.length === 0) {
-    log2.warn("No AI coding agents detected.");
-    log2.info(
+    log.warn("No AI coding agents detected.");
+    log.info(
       "Supported agents: claude-code, opencode, cursor, windsurf, cline, and more."
     );
-    log2.info(
-      "Use --agents to specify agents manually: braid install -p my-profile -a claude-code"
+    log.info(
+      "Select agents manually below. Detected agents are pre-selected when available."
     );
-    process.exit(1);
+    return {
+      availableAgents: getSelectableAgents(options),
+      preselectedAgents: []
+    };
   }
-  return detectedAgents;
+  return {
+    availableAgents: getSelectableAgents(options),
+    preselectedAgents: detectedAgents
+  };
 }
-async function selectAgents(detectedAgents, options) {
+async function selectAgents(availableAgents, preselectedAgents, options) {
   if (options.yes) {
-    return detectedAgents;
+    return preselectedAgents.length > 0 ? preselectedAgents : availableAgents;
   }
-  const agentChoices = detectedAgents.map((agent) => ({
+  const agentChoices = availableAgents.map((agent) => ({
     value: agent,
     label: agent.name,
-    hint: options.global ? agent.globalPath : agent.projectPath
+    ...(options.global ? agent.globalPath || agent.rulesGlobalPath : agent.projectPath || agent.rulesProjectPath) ? {
+      hint: options.global ? agent.globalPath || agent.rulesGlobalPath : agent.projectPath || agent.rulesProjectPath
+    } : {}
   }));
   const selected = await multiselect({
     message: "Select agents to install to:",
     options: agentChoices,
-    initialValues: detectedAgents,
+    initialValues: preselectedAgents,
     required: true
   });
-  if (isCancel2(selected)) {
-    cancel2("Install cancelled.");
+  if (isCancel(selected)) {
+    cancel("Install cancelled.");
     process.exit(0);
   }
   return selected;
@@ -1423,7 +2325,7 @@ async function installSkillsToAgent(agent, response, installPath) {
   }
   const result = await writeSkillsAsync(installPath, response.skills, agent.id);
   for (const err of result.errors) {
-    log2.warn(`  Failed skill: ${err.skill} - ${err.error}`);
+    log.warn(`  Failed skill: ${err.skill} - ${err.error}`);
   }
   return { written: result.written.length, errors: result.errors.length };
 }
@@ -1437,7 +2339,7 @@ async function installRulesToAgent(agent, response, options) {
   }
   const result = await writeRulesForAgentAsync(agent, rules, rulesPath);
   for (const err of result.errors) {
-    log2.warn(`  Failed rules: ${err.agent} - ${err.error}`);
+    log.warn(`  Failed rules: ${err.agent} - ${err.error}`);
   }
   return { written: result.written, errors: result.errors.length };
 }
@@ -1487,9 +2389,9 @@ async function installCommand(options) {
   const resolved = resolveInstallConfig(options, config);
   validateInstallOptions(resolved);
   const sourceDesc = buildSourceDescription(resolved);
-  intro2(`Installing from ${sourceDesc}`);
-  const installSpinner = spinner2();
-  installSpinner.start("Fetching from Braid...");
+  intro(`Installing from ${sourceDesc}`);
+  const installSpinner = spinner();
+  installSpinner.start("Fetching from braid...");
   try {
     const fetchOptions = buildFetchOptions(resolved);
     const response = await fetchSkillsAsync(fetchOptions);
@@ -1504,7 +2406,7 @@ async function installCommand(options) {
     }
     installSpinner.stop(`Found ${foundParts.join(", ") || "nothing"}`);
     if (skillCount === 0 && ruleCount === 0) {
-      log2.warn(
+      log.warn(
         "No skills or rules found. Check that your profile/project has enabled prompts."
       );
       process.exit(0);
@@ -1512,10 +2414,12 @@ async function installCommand(options) {
     if (options.list) {
       displaySkillsAndExit(response.skills);
     }
-    let selectedAgents = await resolveAgents(options, installSpinner);
-    if (!options.agents) {
-      selectedAgents = await selectAgents(selectedAgents, options);
-    }
+    const agentResolution = await resolveAgents(options, installSpinner);
+    const selectedAgents = await selectAgents(
+      agentResolution.availableAgents,
+      agentResolution.preselectedAgents,
+      options
+    );
     let totalWritten = 0;
     let totalErrors = 0;
     for (const agent of selectedAgents) {
@@ -1530,24 +2434,24 @@ async function installCommand(options) {
       totalErrors += result.errors;
     }
     if (totalErrors > 0) {
-      outro2(`Installed ${totalWritten} items with ${totalErrors} errors.`);
+      outro(`Installed ${totalWritten} items with ${totalErrors} errors.`);
     } else {
-      outro2(
+      outro(
         `Successfully installed ${totalWritten} items to ${selectedAgents.length} agent(s).`
       );
     }
-    log2.info("Run 'braid list' to see installed skills.");
+    log.info("Run 'braid list' to see installed skills.");
   } catch (error) {
     installSpinner.stop("Install failed");
     const message = error instanceof Error ? error.message : String(error);
-    log2.error(message);
+    log.error(message);
     process.exit(1);
   }
 }
 
 // src/commands/list.ts
 init_esm_shims();
-import { log as log3, spinner as spinner3 } from "@clack/prompts";
+import { log as log2, spinner as spinner2 } from "@clack/prompts";
 function formatRelativeTime(isoDate) {
   const date = new Date(isoDate);
   const now = /* @__PURE__ */ new Date();
@@ -1573,16 +2477,16 @@ function displayAgentSkills(agent, installPath, braidSkills) {
   const nameWidth = 25;
   const sourceWidth = 20;
   const installedWidth = 15;
-  log3.info("");
-  log3.info(`Agent: ${agent.name} (${installPath})`);
-  log3.info("\u2500".repeat(60));
+  log2.info("");
+  log2.info(`Agent: ${agent.name} (${installPath})`);
+  log2.info("\u2500".repeat(60));
   const header = [
     "Skill".padEnd(nameWidth),
     "Source".padEnd(sourceWidth),
     "Installed".padEnd(installedWidth)
   ].join(" ");
-  log3.info(header);
-  log3.info("\u2500".repeat(60));
+  log2.info(header);
+  log2.info("\u2500".repeat(60));
   for (const skill of braidSkills) {
     const sourceName = skill.source.name;
     const row = [
@@ -1590,17 +2494,17 @@ function displayAgentSkills(agent, installPath, braidSkills) {
       sourceName.slice(0, sourceWidth).padEnd(sourceWidth),
       formatRelativeTime(skill.installedAt).padEnd(installedWidth)
     ].join(" ");
-    log3.info(row);
+    log2.info(row);
   }
 }
 async function listCommand(options) {
-  const listSpinner = spinner3();
+  const listSpinner = spinner2();
   listSpinner.start("Scanning for installed skills...");
   try {
     const detectedAgents = await detectAgentsAsync();
     if (detectedAgents.length === 0) {
       listSpinner.stop("No agents detected");
-      log3.warn("No AI coding agents detected.");
+      log2.warn("No AI coding agents detected.");
       return;
     }
     listSpinner.stop(`Found ${detectedAgents.length} agent(s)`);
@@ -1625,25 +2529,372 @@ async function listCommand(options) {
       displayAgentSkills(agent, installPath, braidSkills);
     }
     if (totalSkills === 0) {
-      log3.warn("\nNo skills installed via braid.");
-      log3.info("Run 'braid install --profile <name>' to install skills.");
+      log2.warn("\nNo skills installed via braid.");
+      log2.info("Run 'braid install --profile <name>' to install skills.");
     } else {
-      log3.info("");
-      log3.info(`Total: ${totalSkills} skill(s) installed`);
+      log2.info("");
+      log2.info(`Total: ${totalSkills} skill(s) installed`);
     }
   } catch (error) {
     listSpinner.stop("List failed");
     const message = error instanceof Error ? error.message : String(error);
-    log3.error(message);
+    log2.error(message);
     process.exit(1);
   }
 }
 
+// src/commands/mcp.ts
+init_esm_shims();
+import process7 from "process";
+init_config();
+
+// src/lib/mcp-config.ts
+init_esm_shims();
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname4 } from "path";
+import { Data as Data6, Effect as Effect7, pipe as pipe7 } from "effect";
+var McpConfigReadError = class extends Data6.TaggedError("McpConfigReadError") {
+};
+var McpConfigWriteError = class extends Data6.TaggedError("McpConfigWriteError") {
+};
+var readMcpConfig = (path2) => pipe7(
+  Effect7.tryPromise({
+    try: () => readFile4(path2, "utf-8"),
+    catch: (e) => new McpConfigReadError({ path: path2, cause: e })
+  }),
+  Effect7.flatMap(
+    (content) => Effect7.try({
+      try: () => JSON.parse(content),
+      catch: () => ({})
+    })
+  ),
+  Effect7.orElseSucceed(() => ({}))
+);
+var writeMcpConfig = (path2, config) => Effect7.tryPromise({
+  try: async () => {
+    await mkdir4(dirname4(path2), { recursive: true });
+    await writeFile5(path2, `${JSON.stringify(config, null, 2)}
+`, "utf-8");
+  },
+  catch: (e) => new McpConfigWriteError({ path: path2, cause: e })
+});
+var mergebraidEntry = (config, rootKey, entryName, entry) => {
+  const servers = config[rootKey] ?? {};
+  return {
+    ...config,
+    [rootKey]: {
+      ...servers,
+      [entryName]: entry
+    }
+  };
+};
+var removebraidEntry = (config, rootKey, entryName) => {
+  const servers = { ...config[rootKey] ?? {} };
+  delete servers[entryName];
+  return {
+    ...config,
+    [rootKey]: servers
+  };
+};
+var hasbraidEntry = (config, rootKey, entryName) => {
+  const servers = config[rootKey];
+  return servers !== void 0 && entryName in servers;
+};
+var readMcpConfigAsync = (path2) => Effect7.runPromise(readMcpConfig(path2));
+var writeMcpConfigAsync = (path2, config) => Effect7.runPromise(writeMcpConfig(path2, config));
+
+// src/commands/mcp.ts
+init_tui();
+var BRAID_ENTRY_NAME = "braid";
+function maskToken(token) {
+  if (token.length <= 10) {
+    return token;
+  }
+  return `${token.slice(0, 7)}...${token.slice(-4)}`;
+}
+function getMcpAgents() {
+  return AGENTS.filter(hasMcpConfig);
+}
+function resolveScope(agent, options) {
+  if (options.global) {
+    return "global";
+  }
+  if (agent.mcpProjectConfigPath) {
+    return "project";
+  }
+  return "global";
+}
+async function selectTool(mcpAgents, toolFlag) {
+  if (toolFlag) {
+    const agent = mcpAgents.find((a) => a.id === toolFlag);
+    if (!agent) {
+      log.error(`Unknown or unsupported tool: ${toolFlag}`);
+      log.info(`Supported tools: ${mcpAgents.map((a) => a.id).join(", ")}`);
+      process7.exit(1);
+    }
+    return agent;
+  }
+  const detected = await detectMcpAgents();
+  const detectedIds = new Set(detected.map((a) => a.id));
+  const toolChoice = await select({
+    message: "Select tool to configure:",
+    options: mcpAgents.map((agent) => ({
+      value: agent.id,
+      label: agent.name,
+      hint: [
+        agent.mcpProjectConfigPath ?? agent.mcpGlobalConfigPath,
+        detectedIds.has(agent.id) ? "detected" : void 0
+      ].filter(Boolean).join(" \u2014 ")
+    }))
+  });
+  if (isCancel(toolChoice)) {
+    cancel("MCP setup cancelled.");
+    process7.exit(0);
+  }
+  const found = mcpAgents.find((a) => a.id === toolChoice);
+  if (!found) {
+    log.error("Agent not found.");
+    process7.exit(1);
+  }
+  return found;
+}
+async function selectScope(agent, options) {
+  const initial = resolveScope(agent, options);
+  if (options.global || options.yes || !agent.mcpProjectConfigPath || !agent.mcpGlobalConfigPath) {
+    return initial;
+  }
+  const scopeChoice = await select({
+    message: "Where should this be configured?",
+    options: [
+      {
+        value: "project",
+        label: "Project",
+        hint: agent.mcpProjectConfigPath
+      },
+      {
+        value: "global",
+        label: "Global",
+        hint: agent.mcpGlobalConfigPath
+      }
+    ]
+  });
+  if (isCancel(scopeChoice)) {
+    cancel("MCP setup cancelled.");
+    process7.exit(0);
+  }
+  return scopeChoice;
+}
+async function resolveToken(options, existingToken) {
+  if (options.auth === false) {
+    return void 0;
+  }
+  if (options.token) {
+    return options.token;
+  }
+  if (existingToken && options.yes) {
+    return existingToken;
+  }
+  if (existingToken) {
+    const authChoice = await select({
+      message: "Authentication:",
+      options: [
+        {
+          value: "existing",
+          label: `Use existing token (${maskToken(existingToken)})`
+        },
+        { value: "new", label: "Enter a new token" },
+        {
+          value: "skip",
+          label: "Skip \u2014 set BRAID_TOKEN env var later"
+        }
+      ]
+    });
+    if (isCancel(authChoice)) {
+      cancel("MCP setup cancelled.");
+      process7.exit(0);
+    }
+    if (authChoice === "existing") {
+      return existingToken;
+    }
+    if (authChoice === "skip") {
+      return void 0;
+    }
+  }
+  const token = await password({
+    message: "Enter your braid API token:",
+    validate: (value) => {
+      if (!value) {
+        return "Token is required";
+      }
+      if (!value.startsWith("br_")) {
+        return "Token should start with 'br_'";
+      }
+      return void 0;
+    }
+  });
+  if (isCancel(token)) {
+    cancel("MCP setup cancelled.");
+    process7.exit(0);
+  }
+  return token;
+}
+function buildEnvVars(token, server) {
+  const env = {};
+  if (token) {
+    env.BRAID_TOKEN = token;
+  }
+  if (server) {
+    env.BRAID_MCP_URL = server;
+  }
+  return env;
+}
+async function writeEntry(agent, configPath, env) {
+  const entry = buildMcpEntry(agent.mcpEntryStyle ?? "standard", env);
+  const rootKey = agent.mcpRootKey ?? "mcpServers";
+  const existingConfig = await readMcpConfigAsync(configPath);
+  const updatedConfig = mergebraidEntry(
+    existingConfig,
+    rootKey,
+    BRAID_ENTRY_NAME,
+    entry
+  );
+  await writeMcpConfigAsync(configPath, updatedConfig);
+}
+async function addFlow(options) {
+  const config = await loadMergedConfigAsync();
+  const mcpAgents = getMcpAgents();
+  if (mcpAgents.length === 0) {
+    log.error("No agents with MCP configuration support found.");
+    process7.exit(1);
+  }
+  const selectedAgent = await selectTool(mcpAgents, options.tool);
+  const scope = await selectScope(selectedAgent, options);
+  const configPath = resolveMcpConfigPath(selectedAgent, {
+    global: scope === "global"
+  });
+  if (!configPath) {
+    log.error(`No ${scope} config path available for ${selectedAgent.name}.`);
+    process7.exit(1);
+  }
+  const token = await resolveToken(options, config.token);
+  const env = buildEnvVars(token, options.server);
+  if (options.scope) {
+    const { scopeCommand: scopeCommand2 } = await Promise.resolve().then(() => (init_scope(), scope_exports));
+    await scopeCommand2({
+      server: options.server ?? config.serverUrl,
+      ...config.token ? { apiKey: config.token } : {}
+    });
+  }
+  const mcpSpinner = spinner();
+  mcpSpinner.start(`Configuring ${selectedAgent.name}...`);
+  try {
+    await writeEntry(selectedAgent, configPath, env);
+    mcpSpinner.stop(`Configured ${selectedAgent.name}`);
+    log.info(`Config written to ${configPath}`);
+    if (!token) {
+      log.info("Set BRAID_TOKEN environment variable before using.");
+    }
+    outro(`Done! Restart ${selectedAgent.name} to activate.`);
+  } catch (error) {
+    mcpSpinner.stop("Configuration failed");
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`Failed to write config: ${message}`);
+    process7.exit(1);
+  }
+}
+async function removeFlow(options) {
+  const mcpAgents = getMcpAgents();
+  const selectedAgent = await selectTool(mcpAgents, options.tool);
+  const scope = resolveScope(selectedAgent, options);
+  const configPath = resolveMcpConfigPath(selectedAgent, {
+    global: scope === "global"
+  });
+  if (!configPath) {
+    log.error(`No ${scope} config path available for ${selectedAgent.name}.`);
+    process7.exit(1);
+  }
+  const removeSpinner = spinner();
+  removeSpinner.start(`Removing braid from ${selectedAgent.name}...`);
+  try {
+    const rootKey = selectedAgent.mcpRootKey ?? "mcpServers";
+    const existingConfig = await readMcpConfigAsync(configPath);
+    if (!hasbraidEntry(existingConfig, rootKey, BRAID_ENTRY_NAME)) {
+      removeSpinner.stop("No braid MCP entry found");
+      log.info(
+        `${selectedAgent.name} doesn't have a braid MCP entry at ${configPath}`
+      );
+      return;
+    }
+    const updatedConfig = removebraidEntry(
+      existingConfig,
+      rootKey,
+      BRAID_ENTRY_NAME
+    );
+    await writeMcpConfigAsync(configPath, updatedConfig);
+    removeSpinner.stop(`Removed braid from ${selectedAgent.name}`);
+    outro(`braid MCP removed from ${configPath}`);
+  } catch (error) {
+    removeSpinner.stop("Removal failed");
+    const message = error instanceof Error ? error.message : String(error);
+    log.error(`Failed to remove config: ${message}`);
+    process7.exit(1);
+  }
+}
+async function statusFlow() {
+  const mcpAgents = getMcpAgents();
+  const statusSpinner = spinner();
+  statusSpinner.start("Checking MCP configuration status...");
+  const results = [];
+  for (const agent of mcpAgents) {
+    const rootKey = agent.mcpRootKey ?? "mcpServers";
+    for (const scope of ["project", "global"]) {
+      const configPath = resolveMcpConfigPath(agent, {
+        global: scope === "global"
+      });
+      if (!configPath) {
+        continue;
+      }
+      const config = await readMcpConfigAsync(configPath);
+      if (hasbraidEntry(config, rootKey, BRAID_ENTRY_NAME)) {
+        results.push({
+          name: agent.name,
+          path: configPath,
+          scope
+        });
+      }
+    }
+  }
+  statusSpinner.stop(`Found ${results.length} configured tool(s)`);
+  if (results.length === 0) {
+    log.info("No tools have braid MCP configured.");
+    log.info("Run 'braid mcp' to set up MCP for your AI tools.");
+    return;
+  }
+  for (const result of results) {
+    log.info(`  ${result.name} (${result.scope}) \u2192 ${result.path}`);
+  }
+}
+async function mcpCommand(options) {
+  if (options.status) {
+    intro("braid mcp status");
+    await statusFlow();
+    return;
+  }
+  if (options.remove) {
+    intro("braid mcp remove");
+    await removeFlow(options);
+    return;
+  }
+  intro("braid mcp");
+  await addFlow(options);
+}
+
 // src/commands/remove.ts
 init_esm_shims();
 import { rm } from "fs/promises";
 import { join as join4, resolve as resolve3 } from "path";
-import process6 from "process";
+import process8 from "process";
+init_tui();
 async function collectInstalledSkills(detectedAgents, options) {
   const skillsToRemove = [];
   for (const agent of detectedAgents) {
@@ -1673,9 +2924,9 @@ async function selectSkillsToRemove(skillsToRemove, options) {
   if (options.skill) {
     const selected = skillsToRemove.filter((s) => s.name === options.skill);
     if (selected.length === 0) {
-      log2.error(`Skill '${options.skill}' not found.`);
-      log2.info("Run 'braid list' to see installed skills.");
-      process6.exit(1);
+      log.error(`Skill '${options.skill}' not found.`);
+      log.info("Run 'braid list' to see installed skills.");
+      process8.exit(1);
     }
     return selected;
   }
@@ -1692,9 +2943,9 @@ async function selectSkillsToRemove(skillsToRemove, options) {
     options: choices,
     required: true
   });
-  if (isCancel2(result)) {
-    cancel2("Remove cancelled.");
-    process6.exit(0);
+  if (isCancel(result)) {
+    cancel("Remove cancelled.");
+    process8.exit(0);
   }
   return result;
 }
@@ -1702,13 +2953,13 @@ async function confirmRemoval(selectedCount, options) {
   if (options.yes || options.skill || options.all) {
     return;
   }
-  const confirmed = await confirm2({
+  const confirmed = await confirm({
     message: `Remove ${selectedCount} skill(s)?`,
     initialValue: false
   });
-  if (isCancel2(confirmed) || !confirmed) {
-    cancel2("Remove cancelled.");
-    process6.exit(0);
+  if (isCancel(confirmed) || !confirmed) {
+    cancel("Remove cancelled.");
+    process8.exit(0);
   }
 }
 async function removeSkill(skill, removeSpinner) {
@@ -1718,7 +2969,7 @@ async function removeSkill(skill, removeSpinner) {
     const resolvedInstallPath = resolve3(skill.installPath);
     if (!resolvedSkillPath.startsWith(`${resolvedInstallPath}/`)) {
       removeSpinner.stop(`Unsafe path for ${skill.name}`);
-      log2.warn("  Skill path escapes install directory, skipping.");
+      log.warn("  Skill path escapes install directory, skipping.");
       return false;
     }
     await rm(resolvedSkillPath, { recursive: true, force: true });
@@ -1728,18 +2979,18 @@ async function removeSkill(skill, removeSpinner) {
   } catch (error) {
     removeSpinner.stop(`Failed to remove ${skill.name}`);
     const message = error instanceof Error ? error.message : String(error);
-    log2.warn(`  ${message}`);
+    log.warn(`  ${message}`);
     return false;
   }
 }
 async function removeCommand(options) {
-  const removeSpinner = spinner2();
+  const removeSpinner = spinner();
   removeSpinner.start("Scanning for installed skills...");
   try {
     const detectedAgents = await detectAgentsAsync();
     if (detectedAgents.length === 0) {
       removeSpinner.stop("No agents detected");
-      log2.warn("No AI coding agents detected.");
+      log.warn("No AI coding agents detected.");
       return;
     }
     const skillsToRemove = await collectInstalledSkills(
@@ -1748,7 +2999,7 @@ async function removeCommand(options) {
     );
     removeSpinner.stop(`Found ${skillsToRemove.length} installed skill(s)`);
     if (skillsToRemove.length === 0) {
-      log2.warn("No skills installed via braid.");
+      log.warn("No skills installed via braid.");
       return;
     }
     const selected = await selectSkillsToRemove(skillsToRemove, options);
@@ -1764,32 +3015,36 @@ async function removeCommand(options) {
       }
     }
     if (errors > 0) {
-      outro2(`Removed ${removed} skill(s) with ${errors} error(s).`);
+      outro(`Removed ${removed} skill(s) with ${errors} error(s).`);
     } else {
-      outro2(`Successfully removed ${removed} skill(s).`);
+      outro(`Successfully removed ${removed} skill(s).`);
     }
   } catch (error) {
     removeSpinner.stop("Remove failed");
     const message = error instanceof Error ? error.message : String(error);
-    log2.error(message);
-    process6.exit(1);
+    log.error(message);
+    process8.exit(1);
   }
 }
 
+// src/index.ts
+init_scope();
+
 // src/commands/update.ts
 init_esm_shims();
 import {
-  cancel as cancel3,
-  isCancel as isCancel3,
-  log as log4,
+  cancel as cancel2,
+  isCancel as isCancel2,
+  log as log3,
   multiselect as multiselect2,
-  outro as outro3,
-  spinner as spinner4
+  outro as outro2,
+  spinner as spinner3
 } from "@clack/prompts";
-import { Data as Data6, Effect as Effect7, pipe as pipe7 } from "effect";
-var UpdateError = class extends Data6.TaggedError("UpdateError") {
+import { Data as Data7, Effect as Effect8, pipe as pipe8 } from "effect";
+init_api();
+var UpdateError = class extends Data7.TaggedError("UpdateError") {
 };
-var UserCancelledError = class extends Data6.TaggedError("UserCancelledError") {
+var UserCancelledError = class extends Data7.TaggedError("UserCancelledError") {
 };
 async function resolveValidInstallPath(agent, options) {
   const installPath = resolveInstallPath(agent, {
@@ -1801,7 +3056,7 @@ async function resolveValidInstallPath(agent, options) {
   const exists = await directoryExistsAsync(installPath);
   return exists ? installPath : null;
 }
-var collectSourcesFromAgent = (agent, options, sourcesToUpdate) => Effect7.tryPromise({
+var collectSourcesFromAgent = (agent, options, sourcesToUpdate) => Effect8.tryPromise({
   try: async () => {
     const installPath = await resolveValidInstallPath(agent, options);
     if (!installPath) {
@@ -1832,10 +3087,10 @@ var collectSourcesFromAgent = (agent, options, sourcesToUpdate) => Effect7.tryPr
   },
   catch: () => new UpdateError({ message: "Failed to collect sources" })
 });
-var collectSources = (detectedAgents, options) => pipe7(
-  Effect7.succeed(/* @__PURE__ */ new Map()),
-  Effect7.tap(
-    (sourcesToUpdate) => Effect7.forEach(
+var collectSources = (detectedAgents, options) => pipe8(
+  Effect8.succeed(/* @__PURE__ */ new Map()),
+  Effect8.tap(
+    (sourcesToUpdate) => Effect8.forEach(
       detectedAgents,
       (agent) => collectSourcesFromAgent(agent, options, sourcesToUpdate),
       { concurrency: 1 }
@@ -1844,9 +3099,9 @@ var collectSources = (detectedAgents, options) => pipe7(
 );
 var selectSources = (sourcesToUpdate, options) => {
   if (options.yes) {
-    return Effect7.succeed(sourcesToUpdate);
+    return Effect8.succeed(sourcesToUpdate);
   }
-  return Effect7.tryPromise({
+  return Effect8.tryPromise({
     try: async () => {
       const sources = Array.from(sourcesToUpdate.entries()).map(
         ([key, source]) => ({
@@ -1861,7 +3116,7 @@ var selectSources = (sourcesToUpdate, options) => {
         initialValues: sources.map((s) => s.value),
         required: true
       });
-      if (isCancel3(selected)) {
+      if (isCancel2(selected)) {
         throw new Error("cancelled");
       }
       for (const key of sourcesToUpdate.keys()) {
@@ -1897,7 +3152,7 @@ var buildFetchOptionsForSource = (source, options) => {
   }
   return fetchOptions;
 };
-var updateAgentSkills = (agentId, agentName, installPath, response, serverUrl, updateSpinner) => Effect7.tryPromise({
+var updateAgentSkills = (agentId, agentName, installPath, response, serverUrl, updateSpinner) => Effect8.tryPromise({
   try: async () => {
     updateSpinner.start(`Updating ${agentName}...`);
     const result = await writeSkillsAsync(
@@ -1935,15 +3190,15 @@ var updateSource = (source, options, updateSpinner) => {
   const serverUrl = options.server ?? source.serverUrl;
   const fetchOptions = buildFetchOptionsForSource(source, options);
   if (fetchOptions === null) {
-    return Effect7.fail(
+    return Effect8.fail(
       new UpdateError({
         message: "Skills installed with legacy metadata format. Please reinstall using 'braid install --profile <name>' or 'braid install --projects <names>'.",
         source: sourceDesc
       })
     );
   }
-  return pipe7(
-    Effect7.tryPromise({
+  return pipe8(
+    Effect8.tryPromise({
       try: async () => {
         updateSpinner.start(`Fetching latest skills from ${sourceDesc}...`);
         const response = await fetchSkillsAsync(fetchOptions);
@@ -1957,9 +3212,9 @@ var updateSource = (source, options, updateSpinner) => {
         source: sourceDesc
       })
     }),
-    Effect7.flatMap(
-      (response) => pipe7(
-        Effect7.forEach(
+    Effect8.flatMap(
+      (response) => pipe8(
+        Effect8.forEach(
           source.agents,
           ({ agentId, agentName, installPath }) => updateAgentSkills(
             agentId,
@@ -1971,7 +3226,7 @@ var updateSource = (source, options, updateSpinner) => {
           ),
           { concurrency: 1 }
         ),
-        Effect7.map((results) => ({
+        Effect8.map((results) => ({
           updated: results.reduce((sum, r) => sum + r.updated, 0),
           errors: results.reduce((sum, r) => sum + r.errors, 0)
         }))
@@ -1979,22 +3234,22 @@ var updateSource = (source, options, updateSpinner) => {
     )
   );
 };
-var updateAllSources = (sources, options, updateSpinner) => pipe7(
-  Effect7.forEach(
+var updateAllSources = (sources, options, updateSpinner) => pipe8(
+  Effect8.forEach(
     Array.from(sources.values()),
-    (source) => pipe7(
+    (source) => pipe8(
       updateSource(source, options, updateSpinner),
-      Effect7.catchAll((error) => {
+      Effect8.catchAll((error) => {
         updateSpinner.stop(
           `Failed to update from ${getSourceDesc(source)}`
         );
-        log4.error(`  ${error.message}`);
-        return Effect7.succeed({ updated: 0, errors: 1 });
+        log3.error(`  ${error.message}`);
+        return Effect8.succeed({ updated: 0, errors: 1 });
       })
     ),
     { concurrency: 1 }
   ),
-  Effect7.map((results) => ({
+  Effect8.map((results) => ({
     totalUpdated: results.reduce((sum, r) => sum + r.updated, 0),
     totalErrors: results.reduce((sum, r) => sum + r.errors, 0)
   }))
@@ -2002,15 +3257,15 @@ var updateAllSources = (sources, options, updateSpinner) => pipe7(
 var handleUpdateError = (error, updateSpinner) => {
   updateSpinner.stop("Update failed");
   if (error.message === "No AI coding agents detected.") {
-    log4.warn(error.message);
+    log3.warn(error.message);
     return;
   }
   if (error.message === "No skills installed via braid.") {
-    log4.warn(error.message);
-    log4.info("Run 'braid install --profile <name>' to install skills first.");
+    log3.warn(error.message);
+    log3.info("Run 'braid install --profile <name>' to install skills first.");
     return;
   }
-  log4.error(error.message);
+  log3.error(error.message);
   process.exit(1);
 };
 var handleProgramExit = (result, updateSpinner) => {
@@ -2023,7 +3278,7 @@ var handleProgramExit = (result, updateSpinner) => {
   }
   const error = cause.error;
   if (error._tag === "UserCancelledError") {
-    cancel3(error.message);
+    cancel2(error.message);
     process.exit(0);
   }
   if (error._tag === "UpdateError") {
@@ -2031,38 +3286,38 @@ var handleProgramExit = (result, updateSpinner) => {
   }
 };
 async function updateCommand(options) {
-  const updateSpinner = spinner4();
+  const updateSpinner = spinner3();
   updateSpinner.start("Scanning for installed skills...");
-  const program2 = pipe7(
-    Effect7.tryPromise({
+  const program2 = pipe8(
+    Effect8.tryPromise({
       try: () => detectAgentsAsync(),
       catch: () => new UpdateError({ message: "Failed to detect agents" })
     }),
-    Effect7.filterOrFail(
+    Effect8.filterOrFail(
       (agents) => agents.length > 0,
       () => new UpdateError({ message: "No AI coding agents detected." })
     ),
-    Effect7.flatMap((detectedAgents) => collectSources(detectedAgents, options)),
-    Effect7.tap((sources) => {
+    Effect8.flatMap((detectedAgents) => collectSources(detectedAgents, options)),
+    Effect8.tap((sources) => {
       updateSpinner.stop(`Found ${sources.size} source(s) to update`);
     }),
-    Effect7.filterOrFail(
+    Effect8.filterOrFail(
       (sources) => sources.size > 0,
       () => new UpdateError({ message: "No skills installed via braid." })
     ),
-    Effect7.flatMap((sources) => selectSources(sources, options)),
-    Effect7.flatMap(
+    Effect8.flatMap((sources) => selectSources(sources, options)),
+    Effect8.flatMap(
       (selectedSources) => updateAllSources(selectedSources, options, updateSpinner)
     ),
-    Effect7.tap(({ totalUpdated, totalErrors }) => {
+    Effect8.tap(({ totalUpdated, totalErrors }) => {
       if (totalErrors > 0) {
-        outro3(`Updated ${totalUpdated} skills with ${totalErrors} errors.`);
+        outro2(`Updated ${totalUpdated} skills with ${totalErrors} errors.`);
       } else {
-        outro3(`Successfully updated ${totalUpdated} skills.`);
+        outro2(`Successfully updated ${totalUpdated} skills.`);
       }
     })
   );
-  const result = await Effect7.runPromiseExit(program2);
+  const result = await Effect8.runPromiseExit(program2);
   handleProgramExit(result, updateSpinner);
 }
 
@@ -2071,10 +3326,10 @@ var require2 = createRequire(import.meta.url);
 var { version: PACKAGE_VERSION } = require2("../package.json");
 var program = new Command();
 program.name("braid").description(
-  "Install Braid prompts as agent skills to your local development environment"
+  "Install braid prompts as agent skills to your local development environment"
 ).version(PACKAGE_VERSION);
-var auth = program.command("auth").description("Configure API key for Braid authentication");
-auth.command("login", { isDefault: true }).description("Configure API key").option("-s, --server <url>", "Braid server URL (for review apps, local dev)").action(authCommand);
+var auth = program.command("auth").description("Configure API key for braid authentication");
+auth.command("login", { isDefault: true }).description("Configure API key").option("-s, --server <url>", "braid server URL (for review apps, local dev)").action(authCommand);
 auth.command("status").description("Show current authentication status").action(authStatusCommand);
 auth.command("logout").description("Remove stored API key").action(authLogoutCommand);
 program.command("install").alias("add").description("Install skills from a profile or project").option("-p, --profile <name>", "Profile name to install from").option(
@@ -2092,9 +3347,32 @@ program.command("install").alias("add").description("Install skills from a profi
 ).option("--no-include-org-globals", "Exclude organization's global prompts").option(
   "-a, --agents <list>",
   "Comma-separated list of agents (e.g., claude-code,opencode)"
-).option("-g, --global", "Install to global agent directories").option("-y, --yes", "Skip confirmation prompts").option("-l, --list", "Preview skills without installing").option("-s, --server <url>", "Braid server URL (for review apps, local dev)").action(installCommand);
+).option("-g, --global", "Install to global agent directories").option("-y, --yes", "Skip confirmation prompts").option("-l, --list", "Preview skills without installing").option("-s, --server <url>", "braid server URL (for review apps, local dev)").action(installCommand);
+program.command("scope").description("Interactively configure braid.json or braid.user.json scope").option("--file <target>", "Config file target: user or project").option(
+  "--organization <type>",
+  "Scope organization for non-interactive mode: personal or organization"
+).option(
+  "--source <source>",
+  "Scope source for non-interactive mode: profile or manual"
+).option("--profile <name>", "Profile name for non-interactive mode").option(
+  "--projects <ids>",
+  "Comma-separated project IDs for non-interactive mode"
+).option(
+  "--rule-ids <ids>",
+  "Comma-separated included rule IDs for non-interactive mode"
+).option(
+  "--excluded-rule-ids <ids>",
+  "Comma-separated excluded rule IDs for non-interactive mode"
+).option(
+  "--include-user-global",
+  "Include personal global rules in non-interactive mode"
+).option(
+  "--include-org-global",
+  "Include org global rules in non-interactive mode"
+).option("-s, --server <url>", "braid server URL (for review apps, local dev)").action(scopeCommand);
 program.command("list").alias("ls").description("List installed skills").option("-g, --global", "List skills in global directories only").action(listCommand);
-program.command("update").alias("up").description("Update installed skills to the latest version").option("-g, --global", "Update skills in global directories only").option("-y, --yes", "Skip confirmation prompts").option("-s, --server <url>", "Braid server URL (for review apps, local dev)").action(updateCommand);
+program.command("update").alias("up").description("Update installed skills to the latest version").option("-g, --global", "Update skills in global directories only").option("-y, --yes", "Skip confirmation prompts").option("-s, --server <url>", "braid server URL (for review apps, local dev)").action(updateCommand);
 program.command("remove").alias("rm").description("Remove installed skills").option("-a, --all", "Remove all installed skills").option("-g, --global", "Remove skills from global directories only").option("-y, --yes", "Skip confirmation prompts").option("--skill <name>", "Remove a specific skill by name").action(removeCommand);
+program.command("mcp").description("Configure braid MCP in your AI coding tools").option("-t, --tool <name>", "Tool to configure").option("-g, --global", "Use global config instead of project").option("--token <token>", "API token to embed").option("--no-auth", "Skip authentication setup").option("--scope", "Run interactive scope configuration").option("--remove", "Remove braid MCP from a tool").option("--status", "Show which tools have braid MCP configured").option("-y, --yes", "Skip confirmation prompts").option("-s, --server <url>", "Custom MCP server URL").action(mcpCommand);
 program.parse();
 //# sourceMappingURL=index.js.map