@braid-cloud/cli 0.1.5 → 0.1.6

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, 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,39 @@ var init_config = __esm({
       },
       catch: () => void 0
     }).pipe(Effect.orElseSucceed(() => void 0));
+    resolveUserConfigWritePath = (startDir = process2.cwd()) => findUserConfigFile(startDir) ?? join(startDir, USER_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 = join(startDir, PROJECT_CONFIG_FILENAME);
+      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 +173,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 +310,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 +319,864 @@ var init_config = __esm({
   }
 });
 
-// src/index.ts
-init_esm_shims();
-import { createRequire } from "module";
-import { Command } from "commander";
+// src/lib/api.ts
+import { Data as Data2, Effect as Effect2, pipe as pipe2 } from "effect";
+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))
+        )
+      )
+    );
+    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
+        })
+      })
+    );
+    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));
+  }
+});
 
-// src/commands/auth.ts
-init_esm_shims();
+// src/lib/tui.ts
 import process3 from "process";
 import {
-  cancel,
-  confirm,
-  intro,
-  isCancel,
-  log,
-  outro,
-  password,
-  spinner
+  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();
+  }
+  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}
+`);
+  }
+}
+function outro(message) {
+  if (isTTY) {
+    clackOutro(message);
+  } else {
+    process3.stdout.write(`${message}
 
-// 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 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"
+      }
+    ],
+    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
   );
-};
-var resolveServerUrl = (optionsServerUrl) => {
-  if (optionsServerUrl) {
-    return Effect2.succeed(optionsServerUrl);
+  return orgProjects?.projects ?? [];
+}
+async function selectProjects(organizationContext, scopeOptions) {
+  const availableProjects = projectsForContext(
+    organizationContext,
+    scopeOptions
+  );
+  if (availableProjects.length === 0) {
+    return void 0;
   }
-  return Effect2.tryPromise({
-    try: () => getServerUrlAsync(),
-    catch: () => new NetworkError({ message: "Failed to read config" })
+  const shouldUseProjects = await confirm({
+    message: "Include project rules too?",
+    initialValue: true
   });
-};
-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."
-        })
-      );
+  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 Effect2.fail(
-      new ApiError({
-        message: errorResponse.error || "API request failed",
-        code: errorResponse.code || "UNKNOWN_ERROR",
-        status: response.status
-      })
-    );
+    return {};
+  }
+  const ruleOptions = await fetchRuleOptionsAsync(
+    buildRuleOptionsRequest(
+      organizationContext,
+      projectIds,
+      includeUserGlobal,
+      includeOrgGlobal,
+      serverUrl,
+      apiKey
+    )
+  );
+  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 };
   }
-  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(",")
-    );
+  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 };
   }
-  if (options.includeUserGlobal !== void 0) {
-    url.searchParams.set(
-      "includeUserGlobal",
-      String(options.includeUserGlobal)
+  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);
   }
-  if (options.includeOrgGlobal !== void 0) {
-    url.searchParams.set("includeOrgGlobal", String(options.includeOrgGlobal));
+}
+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();
   }
-  return url;
-};
-var 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 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));
+});
+
+// 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();
@@ -461,35 +1204,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,7 +1308,7 @@ 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 AGENTS = [
@@ -579,6 +1335,8 @@ var AGENTS = [
     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"
@@ -773,6 +1531,8 @@ var AGENTS = [
     name: "Zed",
     projectPath: "",
     globalPath: "",
+    projectMarkerPath: ".zed",
+    globalMarkerPath: join2(home, ".config", "zed"),
     rulesProjectPath: ".zed/rules",
     rulesGlobalPath: join2(home, ".config", "zed", "rules"),
     ruleFormat: "markdown-dir"
@@ -787,7 +1547,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 +1555,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 +1564,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 +1592,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 +1602,12 @@ 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);
 };
 
 // src/commands/install.ts
+init_api();
 init_config();
 
 // src/lib/metadata.ts
@@ -1208,77 +1973,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 +1984,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 +1995,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 +2037,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 +2085,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 +2104,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 +2153,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 +2167,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,8 +2217,8 @@ async function installCommand(options) {
   const resolved = resolveInstallConfig(options, config);
   validateInstallOptions(resolved);
   const sourceDesc = buildSourceDescription(resolved);
-  intro2(`Installing from ${sourceDesc}`);
-  const installSpinner = spinner2();
+  intro(`Installing from ${sourceDesc}`);
+  const installSpinner = spinner();
   installSpinner.start("Fetching from Braid...");
   try {
     const fetchOptions = buildFetchOptions(resolved);
@@ -1504,7 +2234,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 +2242,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 +2262,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 +2305,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 +2322,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,16 +2357,16 @@ 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);
   }
 }
@@ -1643,7 +2375,8 @@ async function listCommand(options) {
 init_esm_shims();
 import { rm } from "fs/promises";
 import { join as join4, resolve as resolve3 } from "path";
-import process6 from "process";
+import process7 from "process";
+init_tui();
 async function collectInstalledSkills(detectedAgents, options) {
   const skillsToRemove = [];
   for (const agent of detectedAgents) {
@@ -1673,9 +2406,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.");
+      process7.exit(1);
     }
     return selected;
   }
@@ -1692,9 +2425,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.");
+    process7.exit(0);
   }
   return result;
 }
@@ -1702,13 +2435,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.");
+    process7.exit(0);
   }
 }
 async function removeSkill(skill, removeSpinner) {
@@ -1718,7 +2451,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 +2461,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 +2481,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,29 +2497,33 @@ 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);
+    process7.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";
+init_api();
 var UpdateError = class extends Data6.TaggedError("UpdateError") {
 };
 var UserCancelledError = class extends Data6.TaggedError("UserCancelledError") {
@@ -1861,7 +2598,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()) {
@@ -1988,7 +2725,7 @@ var updateAllSources = (sources, options, updateSpinner) => pipe7(
         updateSpinner.stop(
           `Failed to update from ${getSourceDesc(source)}`
         );
-        log4.error(`  ${error.message}`);
+        log3.error(`  ${error.message}`);
         return Effect7.succeed({ updated: 0, errors: 1 });
       })
     ),
@@ -2002,15 +2739,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 +2760,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,7 +2768,7 @@ 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({
@@ -2056,9 +2793,9 @@ async function updateCommand(options) {
     ),
     Effect7.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.`);
       }
     })
   );
@@ -2093,6 +2830,28 @@ program.command("install").alias("add").description("Install skills from a profi
   "-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);
+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("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);