@braid-cloud/cli 0.1.0 → 0.1.1

package/dist/index.js

@@ -56,12 +56,12 @@ 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, 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, isValidServerUrl, resolveServerUrlFromConfig, applyConfigSource, applyEnvOverrides, createDefaultMergedConfig, loadMergedConfig, loadConfig, saveConfig, getApiKey, setApiKey, getServerUrl, clearApiKey, loadConfigAsync, loadProjectConfigAsync, loadUserConfigAsync, loadMergedConfigAsync, findProjectConfigFileAsync, findUserConfigFileAsync, saveConfigAsync, getApiKeyAsync, setApiKeyAsync, getServerUrlAsync, clearApiKeyAsync;
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     init_esm_shims();
-    CONFIG_DIR = join(homedir(), ".config", "braid-skills");
+    CONFIG_DIR = join(homedir(), ".config", "braid");
     CONFIG_FILE = join(CONFIG_DIR, "config.json");
     PROJECT_CONFIG_FILENAME = "braid.json";
     USER_CONFIG_FILENAME = "braid.user.json";
@@ -107,11 +107,23 @@ var init_config = __esm({
       },
       catch: () => void 0
     }).pipe(Effect.orElseSucceed(() => void 0));
+    isValidServerUrl = (url) => {
+      try {
+        const parsed = new URL(url);
+        return parsed.protocol === "https:" || parsed.protocol === "http:";
+      } catch {
+        return false;
+      }
+    };
     resolveServerUrlFromConfig = (config) => {
       if (!config) {
         return void 0;
       }
-      return config.skills?.serverUrl ?? config.serverUrl;
+      const url = config.skills?.serverUrl ?? config.serverUrl;
+      if (url && !isValidServerUrl(url)) {
+        return void 0;
+      }
+      return url;
     };
     applyConfigSource = (merged, config) => {
       if (!config) {
@@ -130,11 +142,11 @@ var init_config = __esm({
       if (config.personalProjects) {
         merged.personalProjects = config.personalProjects;
       }
-      if (config.includeUserGlobalRules !== void 0) {
-        merged.includeUserGlobalRules = config.includeUserGlobalRules;
+      if (config.includeUserGlobal !== void 0) {
+        merged.includeUserGlobal = config.includeUserGlobal;
       }
-      if (config.includeOrgGlobalRules !== void 0) {
-        merged.includeOrgGlobalRules = config.includeOrgGlobalRules;
+      if (config.includeOrgGlobal !== void 0) {
+        merged.includeOrgGlobal = config.includeOrgGlobal;
       }
       if (config.agents) {
         merged.agents = config.agents;
@@ -148,14 +160,14 @@ var init_config = __esm({
         merged.token = process2.env.BRAID_API_KEY;
       }
       const envServerUrl = process2.env.BRAID_SKILLS_SERVER_URL ?? process2.env.BRAID_SERVER_URL;
-      if (envServerUrl) {
+      if (envServerUrl && isValidServerUrl(envServerUrl)) {
         merged.serverUrl = envServerUrl;
       }
     };
     createDefaultMergedConfig = () => ({
       serverUrl: "https://braid.cloud",
-      includeUserGlobalRules: true,
-      includeOrgGlobalRules: true
+      includeUserGlobal: true,
+      includeOrgGlobal: true
     });
     loadMergedConfig = () => pipe(
       Effect.all({
@@ -192,8 +204,11 @@ var init_config = __esm({
     saveConfig = (config) => pipe(
       Effect.tryPromise({
         try: async () => {
-          await mkdir(dirname(CONFIG_FILE), { recursive: true });
-          await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+          await mkdir(dirname(CONFIG_FILE), { recursive: true, mode: 448 });
+          await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), {
+            encoding: "utf-8",
+            mode: 384
+          });
         },
         catch: (e) => new ConfigWriteError({ path: CONFIG_FILE, cause: e })
       })
@@ -347,17 +362,14 @@ var buildExportUrl = (serverUrl, options) => {
       options.personalProjects.join(",")
     );
   }
-  if (options.includeUserGlobalRules !== void 0) {
+  if (options.includeUserGlobal !== void 0) {
     url.searchParams.set(
       "includeUserGlobal",
-      String(options.includeUserGlobalRules)
+      String(options.includeUserGlobal)
     );
   }
-  if (options.includeOrgGlobalRules !== void 0) {
-    url.searchParams.set(
-      "includeOrgGlobal",
-      String(options.includeOrgGlobalRules)
-    );
+  if (options.includeOrgGlobal !== void 0) {
+    url.searchParams.set("includeOrgGlobal", String(options.includeOrgGlobal));
   }
   return url;
 };
@@ -422,7 +434,7 @@ var validateApiKeyAsync = (apiKey, serverUrl) => Effect2.runPromise(validateApiK
 // src/commands/auth.ts
 init_config();
 async function authCommand(options) {
-  intro("braid-skills auth");
+  intro("braid auth");
   const config = await loadMergedConfigAsync();
   if (config.token) {
     const shouldReplace = await confirm({
@@ -466,7 +478,7 @@ async function authCommand(options) {
     authSpinner.stop("API key validated and saved");
     log.success(`Config saved to ${CONFIG_FILE}`);
     outro(
-      "You're authenticated! Run 'braid-skills install --profile <name>' to install skills."
+      "You're authenticated! Run 'braid install --profile <name>' to install skills."
     );
   } catch (error) {
     authSpinner.stop("Validation failed");
@@ -514,9 +526,7 @@ function displayResolvedSettings(config) {
 async function authStatusCommand() {
   const config = await loadMergedConfigAsync();
   if (!config.token) {
-    log.warn(
-      "Not authenticated. Run 'braid-skills auth' to configure your API key."
-    );
+    log.warn("Not authenticated. Run 'braid auth' to configure your API key.");
     log.info(
       `Or create a ${USER_CONFIG_FILENAME} file with: { "token": "br_xxx" }`
     );
@@ -567,7 +577,10 @@ var AGENTS = [
     id: "claude-code",
     name: "Claude Code",
     projectPath: ".claude/skills",
-    globalPath: join2(home, ".claude", "skills")
+    globalPath: join2(home, ".claude", "skills"),
+    rulesProjectPath: ".claude/rules",
+    rulesGlobalPath: join2(home, ".claude", "rules"),
+    ruleFormat: "markdown-dir"
   },
   {
     id: "moltbot",
@@ -579,7 +592,9 @@ var AGENTS = [
     id: "cline",
     name: "Cline",
     projectPath: ".cline/skills",
-    globalPath: join2(home, ".cline", "skills")
+    globalPath: join2(home, ".cline", "skills"),
+    rulesProjectPath: ".clinerules",
+    ruleFormat: "append-single"
   },
   {
     id: "codebuddy",
@@ -615,7 +630,9 @@ var AGENTS = [
     id: "cursor",
     name: "Cursor",
     projectPath: ".cursor/skills",
-    globalPath: join2(home, ".cursor", "skills")
+    globalPath: join2(home, ".cursor", "skills"),
+    rulesProjectPath: ".cursor/rules",
+    ruleFormat: "mdc"
   },
   {
     id: "droid",
@@ -633,7 +650,9 @@ var AGENTS = [
     id: "github-copilot",
     name: "GitHub Copilot",
     projectPath: ".github/skills",
-    globalPath: join2(home, ".copilot", "skills")
+    globalPath: join2(home, ".copilot", "skills"),
+    rulesProjectPath: ".github/copilot-instructions.md",
+    ruleFormat: "append-single"
   },
   {
     id: "goose",
@@ -711,7 +730,10 @@ var AGENTS = [
     id: "roo",
     name: "Roo Code",
     projectPath: ".roo/skills",
-    globalPath: join2(home, ".roo", "skills")
+    globalPath: join2(home, ".roo", "skills"),
+    rulesProjectPath: ".roo/rules",
+    rulesGlobalPath: join2(home, ".roo", "rules"),
+    ruleFormat: "markdown-dir"
   },
   {
     id: "trae",
@@ -723,7 +745,9 @@ var AGENTS = [
     id: "windsurf",
     name: "Windsurf",
     projectPath: ".windsurf/skills",
-    globalPath: join2(home, ".codeium", "windsurf", "skills")
+    globalPath: join2(home, ".codeium", "windsurf", "skills"),
+    rulesProjectPath: ".windsurfrules",
+    ruleFormat: "append-single"
   },
   {
     id: "zencoder",
@@ -742,6 +766,15 @@ var AGENTS = [
     name: "Pochi",
     projectPath: ".pochi/skills",
     globalPath: join2(home, ".pochi", "skills")
+  },
+  {
+    id: "zed",
+    name: "Zed",
+    projectPath: "",
+    globalPath: "",
+    rulesProjectPath: ".zed/rules",
+    rulesGlobalPath: join2(home, ".config", "zed", "rules"),
+    ruleFormat: "markdown-dir"
   }
 ];
 var directoryExists = (path2) => pipe3(
@@ -752,10 +785,6 @@ var directoryExists = (path2) => pipe3(
   Effect3.map(() => true),
   Effect3.orElseSucceed(() => false)
 );
-var getAgentConfigDir = (skillsPath) => {
-  const parts = skillsPath.split("/");
-  return parts.slice(0, -1).join("/");
-};
 var detectAgents = (projectRoot) => {
   const cwd = projectRoot ?? process4.cwd();
   return pipe3(
@@ -763,19 +792,25 @@ var detectAgents = (projectRoot) => {
       AGENTS,
       (agent) => pipe3(
         Effect3.all({
-          hasProjectConfig: directoryExists(
-            join2(cwd, getAgentConfigDir(agent.projectPath))
-          ),
-          hasGlobalConfig: directoryExists(getAgentConfigDir(agent.globalPath))
+          hasProjectConfig: agent.projectPath ? directoryExists(join2(cwd, agent.projectPath)) : Effect3.succeed(false),
+          hasGlobalConfig: agent.globalPath ? directoryExists(agent.globalPath) : Effect3.succeed(false),
+          hasRulesProjectConfig: agent.rulesProjectPath ? directoryExists(join2(cwd, agent.rulesProjectPath)) : Effect3.succeed(false),
+          hasRulesGlobalConfig: agent.rulesGlobalPath ? directoryExists(agent.rulesGlobalPath) : Effect3.succeed(false)
         }),
         Effect3.map(
-          ({ hasProjectConfig, hasGlobalConfig }) => ({
-            ...agent,
+          ({
             hasProjectConfig,
-            hasGlobalConfig
+            hasGlobalConfig,
+            hasRulesProjectConfig,
+            hasRulesGlobalConfig
+          }) => ({
+            ...agent,
+            hasProjectConfig: hasProjectConfig || hasRulesProjectConfig,
+            hasGlobalConfig: hasGlobalConfig || hasRulesGlobalConfig
           })
         )
-      )
+      ),
+      { concurrency: "unbounded" }
     ),
     Effect3.map(
       (agents) => agents.filter((a) => a.hasProjectConfig || a.hasGlobalConfig)
@@ -787,11 +822,24 @@ var detectAgentsAsync = (projectRoot) => Effect3.runPromise(detectAgents(project
 var directoryExistsAsync = (path2) => Effect3.runPromise(directoryExists(path2));
 var resolveInstallPath = (agent, options) => {
   if (options.global) {
-    return agent.globalPath;
+    return agent.globalPath || void 0;
+  }
+  if (!agent.projectPath) {
+    return void 0;
   }
   const cwd = options.projectRoot ?? process4.cwd();
   return join2(cwd, agent.projectPath);
 };
+var resolveRulesInstallPath = (agent, options) => {
+  if (options.global) {
+    return agent.rulesGlobalPath;
+  }
+  if (!agent.rulesProjectPath) {
+    return void 0;
+  }
+  const cwd = options.projectRoot ?? process4.cwd();
+  return join2(cwd, agent.rulesProjectPath);
+};
 
 // src/commands/install.ts
 init_config();
@@ -867,12 +915,204 @@ var readMetadataAsync = (skillsDir) => Effect4.runPromise(readMetadata(skillsDir
 var updateMetadataAsync = (skillsDir, newSkills) => Effect4.runPromise(updateMetadata(skillsDir, newSkills));
 var removeFromMetadataAsync = (skillsDir, skillName) => Effect4.runPromise(removeFromMetadata(skillsDir, skillName));
 
-// src/lib/skill-writer.ts
+// src/lib/rule-writer.ts
 init_esm_shims();
-import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, resolve, sep } from "path";
 import { Data as Data4, Effect as Effect5, pipe as pipe5 } from "effect";
-var WriteError = class extends Data4.TaggedError("WriteError") {
+var RuleWriteError = class extends Data4.TaggedError("RuleWriteError") {
+};
+var createDirectory = (dir) => Effect5.tryPromise({
+  try: () => mkdir2(dir, { recursive: true }),
+  catch: (e) => new RuleWriteError({ path: dir, operation: "mkdir", cause: e })
+});
+var writeTextFile = (fullPath, content) => Effect5.tryPromise({
+  try: () => writeFile3(fullPath, content, "utf-8"),
+  catch: (e) => new RuleWriteError({ path: fullPath, operation: "write", cause: e })
+});
+var readTextFile = (fullPath) => Effect5.tryPromise({
+  try: () => readFile3(fullPath, "utf-8"),
+  catch: (e) => new RuleWriteError({ path: fullPath, operation: "read", cause: e })
+});
+var assertRulePathWithinBase = (basePath, ruleName) => {
+  const resolvedBase = resolve(basePath);
+  const resolvedFull = resolve(basePath, ruleName);
+  if (resolvedFull !== resolvedBase && !resolvedFull.startsWith(resolvedBase + sep)) {
+    return Effect5.fail(
+      new RuleWriteError({
+        path: ruleName,
+        operation: "write",
+        cause: new Error(
+          `Path traversal detected: "${ruleName}" resolves outside base directory`
+        )
+      })
+    );
+  }
+  return Effect5.succeed(resolvedFull);
+};
+var BRAID_SECTION_START = "<!-- braid:rules:start -->";
+var BRAID_SECTION_END = "<!-- braid:rules:end -->";
+var YAML_SPECIAL_CHARS = /[\n\r:#{}[\],&*?|>!'"%@`]/;
+function escapeYamlValue(value) {
+  if (YAML_SPECIAL_CHARS.test(value) || value.startsWith(" ") || value.endsWith(" ")) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function buildMdcContent(rule) {
+  const lines = ["---"];
+  lines.push(`description: ${escapeYamlValue(rule.title)}`);
+  lines.push("alwaysApply: true");
+  lines.push("---");
+  lines.push("");
+  lines.push(`# ${rule.title}`);
+  lines.push("");
+  lines.push(rule.content);
+  return lines.join("\n");
+}
+function buildAppendContent(rules) {
+  const lines = [BRAID_SECTION_START, ""];
+  for (const rule of rules) {
+    lines.push(`## ${rule.title}`);
+    lines.push("");
+    lines.push(rule.content);
+    lines.push("");
+  }
+  lines.push(BRAID_SECTION_END);
+  return lines.join("\n");
+}
+var writeMdcRules = (basePath, rules) => pipe5(
+  createDirectory(basePath),
+  Effect5.flatMap(
+    () => Effect5.forEach(
+      rules,
+      (rule) => pipe5(
+        assertRulePathWithinBase(basePath, `${rule.name}.mdc`),
+        Effect5.flatMap(
+          (filePath) => writeTextFile(filePath, buildMdcContent(rule))
+        )
+      ),
+      { concurrency: "unbounded" }
+    )
+  ),
+  Effect5.asVoid
+);
+var writeMarkdownDirRules = (basePath, rules) => pipe5(
+  createDirectory(basePath),
+  Effect5.flatMap(
+    () => Effect5.forEach(
+      rules,
+      (rule) => pipe5(
+        assertRulePathWithinBase(basePath, `${rule.name}.md`),
+        Effect5.flatMap(
+          (filePath) => writeTextFile(filePath, `# ${rule.title}
+
+${rule.content}`)
+        )
+      ),
+      { concurrency: "unbounded" }
+    )
+  ),
+  Effect5.asVoid
+);
+var writeAppendSingleRules = (filePath, rules) => pipe5(
+  createDirectory(dirname2(filePath)),
+  Effect5.flatMap(
+    () => pipe5(
+      readTextFile(filePath),
+      Effect5.orElseSucceed(() => "")
+    )
+  ),
+  Effect5.flatMap((existing) => {
+    const braidContent = buildAppendContent(rules);
+    const startIdx = existing.indexOf(BRAID_SECTION_START);
+    const endIdx = existing.indexOf(BRAID_SECTION_END);
+    let newContent;
+    if (startIdx !== -1 && endIdx !== -1) {
+      newContent = existing.slice(0, startIdx) + braidContent + existing.slice(endIdx + BRAID_SECTION_END.length);
+    } else {
+      newContent = existing ? `${existing}
+
+${braidContent}` : braidContent;
+    }
+    return writeTextFile(filePath, newContent);
+  })
+);
+var writeRulesForFormat = (basePath, rules, format) => {
+  switch (format) {
+    case "mdc":
+      return writeMdcRules(basePath, rules);
+    case "markdown-dir":
+      return writeMarkdownDirRules(basePath, rules);
+    case "append-single":
+      return writeAppendSingleRules(basePath, rules);
+    default:
+      return Effect5.void;
+  }
+};
+var writeRulesForAgent = (agent, rules, rulesPath) => {
+  if (!agent.ruleFormat || rules.length === 0) {
+    return Effect5.succeed({ written: 0, errors: [] });
+  }
+  return pipe5(
+    writeRulesForFormat(rulesPath, rules, agent.ruleFormat),
+    Effect5.map(() => ({
+      written: rules.length,
+      errors: []
+    })),
+    Effect5.catchAll(
+      (error) => Effect5.succeed({
+        written: 0,
+        errors: [
+          {
+            agent: agent.name,
+            error: error.cause instanceof Error ? error.cause.message : String(error.cause)
+          }
+        ]
+      })
+    )
+  );
+};
+var writeRulesForAgentAsync = (agent, rules, rulesPath) => Effect5.runPromise(writeRulesForAgent(agent, rules, rulesPath));
+
+// src/lib/skill-writer.ts
+init_esm_shims();
+import { chmod, mkdir as mkdir3, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname3, resolve as resolve2, sep as sep2 } from "path";
+import { Data as Data5, Effect as Effect6, pipe as pipe6 } from "effect";
+var WriteError = class extends Data5.TaggedError("WriteError") {
+};
+var createDirectory2 = (dir, fullPath) => Effect6.tryPromise({
+  try: () => mkdir3(dir, { recursive: true }),
+  catch: (e) => new WriteError({ path: fullPath, operation: "mkdir", cause: e })
+});
+var writeTextFile2 = (fullPath, content) => Effect6.tryPromise({
+  try: () => writeFile4(fullPath, content, "utf-8"),
+  catch: (e) => new WriteError({ path: fullPath, operation: "write", cause: e })
+});
+var writeBinaryFile = (fullPath, content) => Effect6.tryPromise({
+  try: () => writeFile4(fullPath, content),
+  catch: (e) => new WriteError({ path: fullPath, operation: "write", cause: e })
+});
+var makeExecutable = (fullPath) => Effect6.tryPromise({
+  try: () => chmod(fullPath, 493),
+  catch: (e) => new WriteError({ path: fullPath, operation: "chmod", cause: e })
+});
+var assertWithinBase = (basePath, untrustedPath) => {
+  const resolvedBase = resolve2(basePath);
+  const resolvedFull = resolve2(basePath, untrustedPath);
+  if (resolvedFull !== resolvedBase && !resolvedFull.startsWith(resolvedBase + sep2)) {
+    return Effect6.fail(
+      new WriteError({
+        path: untrustedPath,
+        operation: "write",
+        cause: new Error(
+          `Path traversal detected: "${untrustedPath}" resolves outside base directory`
+        )
+      })
+    );
+  }
+  return Effect6.succeed(resolvedFull);
 };
 var COMPATIBILITY_REGEX = /^compatibility:\s*.+$/m;
 var rewriteCompatibility = (content, agentId) => {
@@ -908,42 +1148,48 @@ var isBinaryFile = (path2) => {
   ];
   return binaryExtensions.some((ext) => path2.toLowerCase().endsWith(ext));
 };
-var writeSkillFile = (basePath, file, agentId) => pipe5(
-  Effect5.tryPromise({
-    try: async () => {
-      const fullPath = join4(basePath, file.path);
-      const dir = dirname2(fullPath);
-      await mkdir2(dir, { recursive: true });
-      if (isBinaryFile(file.path)) {
-        await writeFile3(fullPath, decodeFileContentBinary(file));
-      } else {
-        await writeFile3(fullPath, decodeFileContent(file, agentId), "utf-8");
-      }
-    },
-    catch: (e) => new WriteError({ path: join4(basePath, file.path), cause: e })
+var isScriptFile = (path2) => {
+  const scriptExtensions = [".sh", ".bash", ".py", ".js", ".mjs", ".rb"];
+  const lowerPath = path2.toLowerCase();
+  const inScriptsDir = lowerPath.includes("/scripts/") || lowerPath.startsWith("scripts/");
+  return inScriptsDir && scriptExtensions.some((ext) => lowerPath.endsWith(ext));
+};
+var writeFileContent = (fullPath, file, agentId) => isBinaryFile(file.path) ? writeBinaryFile(fullPath, decodeFileContentBinary(file)) : writeTextFile2(fullPath, decodeFileContent(file, agentId));
+var setExecutableIfScript = (fullPath, filePath) => isScriptFile(filePath) ? makeExecutable(fullPath) : Effect6.void;
+var writeSkillFile = (basePath, file, agentId) => pipe6(
+  assertWithinBase(basePath, file.path),
+  Effect6.flatMap((fullPath) => {
+    const dir = dirname3(fullPath);
+    return pipe6(
+      createDirectory2(dir, fullPath),
+      Effect6.flatMap(() => writeFileContent(fullPath, file, agentId)),
+      Effect6.flatMap(() => setExecutableIfScript(fullPath, file.path))
+    );
   })
 );
-var writeSkill = (basePath, skill, agentId) => {
-  const skillDir = join4(basePath, skill.name);
-  return pipe5(
-    Effect5.forEach(
-      skill.files,
-      (file) => writeSkillFile(skillDir, file, agentId),
-      {
-        concurrency: "unbounded"
-      }
-    ),
-    Effect5.map(() => void 0)
-  );
-};
-var writeSkills = (basePath, skills, agentId) => pipe5(
-  Effect5.forEach(
+var writeSkill = (basePath, skill, agentId) => pipe6(
+  assertWithinBase(basePath, skill.name),
+  Effect6.flatMap(
+    (skillDir) => pipe6(
+      Effect6.forEach(
+        skill.files,
+        (file) => writeSkillFile(skillDir, file, agentId),
+        {
+          concurrency: "unbounded"
+        }
+      ),
+      Effect6.map(() => void 0)
+    )
+  )
+);
+var writeSkills = (basePath, skills, agentId) => pipe6(
+  Effect6.forEach(
     skills,
-    (skill) => pipe5(
+    (skill) => pipe6(
       writeSkill(basePath, skill, agentId),
-      Effect5.map(() => ({ success: true, skill: skill.name })),
-      Effect5.catchAll(
-        (error) => Effect5.succeed({
+      Effect6.map(() => ({ success: true, skill: skill.name })),
+      Effect6.catchAll(
+        (error) => Effect6.succeed({
           success: false,
           skill: skill.name,
           error: error.cause instanceof Error ? error.cause.message : String(error.cause)
@@ -952,14 +1198,14 @@ var writeSkills = (basePath, skills, agentId) => pipe5(
     ),
     { concurrency: "unbounded" }
   ),
-  Effect5.map((results) => ({
+  Effect6.map((results) => ({
     written: results.filter((r) => r.success).map((r) => r.skill),
     errors: results.filter(
       (r) => !r.success
     ).map((r) => ({ skill: r.skill, error: r.error }))
   }))
 );
-var writeSkillsAsync = (basePath, skills, agentId) => Effect5.runPromise(writeSkills(basePath, skills, agentId));
+var writeSkillsAsync = (basePath, skills, agentId) => Effect6.runPromise(writeSkills(basePath, skills, agentId));
 
 // src/lib/tui.ts
 init_esm_shims();
@@ -1038,8 +1284,8 @@ function resolveInstallConfig(options, config) {
   return {
     profile: options.profile ?? config.profile,
     serverUrl: options.server ?? config.serverUrl,
-    includeUserGlobalRules: options.includeUserGlobals ?? config.includeUserGlobalRules,
-    includeOrgGlobalRules: options.includeOrgGlobals ?? config.includeOrgGlobalRules,
+    includeUserGlobal: options.includeUserGlobals ?? config.includeUserGlobal,
+    includeOrgGlobal: options.includeOrgGlobals ?? config.includeOrgGlobal,
     orgProjects: orgProjectsFromFlag ?? config.orgProjects,
     personalProjects: personalProjectsFromFlag ?? config.personalProjects
   };
@@ -1057,9 +1303,9 @@ function validateInstallOptions(resolved) {
     log2.info("  - Use --profile, --org-projects, or --personal-projects flags");
     log2.info("");
     log2.info("Examples:");
-    log2.info("  braid-skills install --profile coding-standards");
-    log2.info("  braid-skills install --org-projects proj123,proj456");
-    log2.info("  braid-skills install --personal-projects myproj1");
+    log2.info("  braid install --profile coding-standards");
+    log2.info("  braid install --org-projects proj123,proj456");
+    log2.info("  braid install --personal-projects myproj1");
     process.exit(1);
   }
 }
@@ -1079,8 +1325,8 @@ function buildSourceDescription(resolved) {
 function buildFetchOptions(resolved) {
   const fetchOptions = {
     serverUrl: resolved.serverUrl,
-    includeUserGlobalRules: resolved.includeUserGlobalRules,
-    includeOrgGlobalRules: resolved.includeOrgGlobalRules
+    includeUserGlobal: resolved.includeUserGlobal,
+    includeOrgGlobal: resolved.includeOrgGlobal
   };
   if (resolved.profile) {
     fetchOptions.profile = resolved.profile;
@@ -1125,15 +1371,25 @@ async function resolveAgents(options, installSpinner) {
     return selectedAgents;
   }
   installSpinner.start("Detecting installed agents...");
-  const detectedAgents = await detectAgentsAsync();
-  installSpinner.stop(`Detected ${detectedAgents.length} agent(s)`);
+  const allDetectedAgents = await detectAgentsAsync();
+  const detectedAgents = allDetectedAgents.filter(
+    (agent) => options.global ? agent.hasGlobalConfig : agent.hasProjectConfig
+  );
+  const targetType = options.global ? "global" : "project";
+  installSpinner.stop(
+    `Detected ${detectedAgents.length} agent(s) with ${targetType} config`
+  );
+  for (const agent of detectedAgents) {
+    const targetPath = options.global ? agent.globalPath : agent.projectPath;
+    log2.info(`  ${agent.name} \u2192 ${targetPath}`);
+  }
   if (detectedAgents.length === 0) {
     log2.warn("No AI coding agents detected.");
     log2.info(
       "Supported agents: claude-code, opencode, cursor, windsurf, cline, and more."
     );
     log2.info(
-      "Use --agents to specify agents manually: braid-skills install -p my-profile -a claude-code"
+      "Use --agents to specify agents manually: braid install -p my-profile -a claude-code"
     );
     process.exit(1);
   }
@@ -1160,50 +1416,95 @@ async function selectAgents(detectedAgents, options) {
   }
   return selected;
 }
+async function installSkillsToAgent(agent, response, installPath) {
+  if (response.skills.length === 0 || !agent.projectPath) {
+    return { written: 0, errors: 0 };
+  }
+  const result = await writeSkillsAsync(installPath, response.skills, agent.id);
+  for (const err of result.errors) {
+    log2.warn(`  Failed skill: ${err.skill} - ${err.error}`);
+  }
+  return { written: result.written.length, errors: result.errors.length };
+}
+async function installRulesToAgent(agent, response, options) {
+  const rules = response.rules ?? [];
+  const rulesPath = resolveRulesInstallPath(agent, {
+    global: options.global === true
+  });
+  if (rules.length === 0 || !rulesPath || !agent.ruleFormat) {
+    return { written: 0, errors: 0 };
+  }
+  const result = await writeRulesForAgentAsync(agent, rules, rulesPath);
+  for (const err of result.errors) {
+    log2.warn(`  Failed rules: ${err.agent} - ${err.error}`);
+  }
+  return { written: result.written, errors: result.errors.length };
+}
+function formatInstallSummary(agentName, skillsWritten, rulesWritten) {
+  const parts = [];
+  if (skillsWritten > 0) {
+    parts.push(`${skillsWritten} skills`);
+  }
+  if (rulesWritten > 0) {
+    parts.push(`${rulesWritten} rules`);
+  }
+  return `${agentName}: ${parts.join(", ")} installed`;
+}
 async function installToAgent(agent, response, serverUrl, options, installSpinner) {
   const installPath = resolveInstallPath(agent, {
     global: options.global === true
   });
   installSpinner.start(`Installing to ${agent.name}...`);
-  const result = await writeSkillsAsync(installPath, response.skills, agent.id);
-  if (result.errors.length > 0) {
+  const skills = installPath ? await installSkillsToAgent(agent, response, installPath) : { written: 0, errors: 0 };
+  const rules = await installRulesToAgent(agent, response, options);
+  const totalWritten = skills.written + rules.written;
+  const totalErrors = skills.errors + rules.errors;
+  if (totalErrors > 0) {
     installSpinner.stop(
-      `${agent.name}: ${result.written.length} installed, ${result.errors.length} failed`
+      `${agent.name}: ${totalWritten} installed, ${totalErrors} failed`
     );
-    for (const err of result.errors) {
-      log2.warn(`  Failed: ${err.skill} - ${err.error}`);
-    }
   } else {
     installSpinner.stop(
-      `${agent.name}: ${result.written.length} skills installed`
+      formatInstallSummary(agent.name, skills.written, rules.written)
     );
   }
-  await updateMetadataAsync(
-    installPath,
-    response.skills.map((s) => ({
-      name: s.name,
-      source: response.source,
-      version: response.version,
-      serverUrl
-    }))
-  );
-  return { written: result.written.length, errors: result.errors.length };
+  if (response.skills.length > 0 && installPath) {
+    await updateMetadataAsync(
+      installPath,
+      response.skills.map((s) => ({
+        name: s.name,
+        source: response.source,
+        version: response.version,
+        serverUrl
+      }))
+    );
+  }
+  return { written: totalWritten, errors: totalErrors };
 }
 async function installCommand(options) {
   const config = await loadMergedConfigAsync();
   const resolved = resolveInstallConfig(options, config);
   validateInstallOptions(resolved);
   const sourceDesc = buildSourceDescription(resolved);
-  intro2(`Installing skills from ${sourceDesc}`);
+  intro2(`Installing from ${sourceDesc}`);
   const installSpinner = spinner2();
-  installSpinner.start("Fetching skills from Braid...");
+  installSpinner.start("Fetching from Braid...");
   try {
     const fetchOptions = buildFetchOptions(resolved);
     const response = await fetchSkillsAsync(fetchOptions);
-    installSpinner.stop(`Found ${response.skills.length} skills`);
-    if (response.skills.length === 0) {
+    const ruleCount = response.rules?.length ?? 0;
+    const skillCount = response.skills.length;
+    const foundParts = [];
+    if (skillCount > 0) {
+      foundParts.push(`${skillCount} skills`);
+    }
+    if (ruleCount > 0) {
+      foundParts.push(`${ruleCount} rules`);
+    }
+    installSpinner.stop(`Found ${foundParts.join(", ") || "nothing"}`);
+    if (skillCount === 0 && ruleCount === 0) {
       log2.warn(
-        "No skills found. Check that your profile/project has enabled rules."
+        "No skills or rules found. Check that your profile/project has enabled prompts."
       );
       process.exit(0);
     }
@@ -1228,13 +1529,13 @@ async function installCommand(options) {
       totalErrors += result.errors;
     }
     if (totalErrors > 0) {
-      outro2(`Installed ${totalWritten} skills with ${totalErrors} errors.`);
+      outro2(`Installed ${totalWritten} items with ${totalErrors} errors.`);
     } else {
       outro2(
-        `Successfully installed ${totalWritten} skills to ${selectedAgents.length} agent(s).`
+        `Successfully installed ${totalWritten} items to ${selectedAgents.length} agent(s).`
       );
     }
-    log2.info("Run 'braid-skills list' to see installed skills.");
+    log2.info("Run 'braid list' to see installed skills.");
   } catch (error) {
     installSpinner.stop("Install failed");
     const message = error instanceof Error ? error.message : String(error);
@@ -1307,6 +1608,9 @@ async function listCommand(options) {
       const installPath = resolveInstallPath(agent, {
         global: options.global === true
       });
+      if (!installPath) {
+        continue;
+      }
       const exists = await directoryExistsAsync(installPath);
       if (!exists) {
         continue;
@@ -1320,10 +1624,8 @@ async function listCommand(options) {
       displayAgentSkills(agent, installPath, braidSkills);
     }
     if (totalSkills === 0) {
-      log3.warn("\nNo skills installed via braid-skills.");
-      log3.info(
-        "Run 'braid-skills install --profile <name>' to install skills."
-      );
+      log3.warn("\nNo skills installed via braid.");
+      log3.info("Run 'braid install --profile <name>' to install skills.");
     } else {
       log3.info("");
       log3.info(`Total: ${totalSkills} skill(s) installed`);
@@ -1339,7 +1641,7 @@ async function listCommand(options) {
 // src/commands/remove.ts
 init_esm_shims();
 import { rm } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join4, resolve as resolve3 } from "path";
 import process6 from "process";
 async function collectInstalledSkills(detectedAgents, options) {
   const skillsToRemove = [];
@@ -1347,6 +1649,9 @@ async function collectInstalledSkills(detectedAgents, options) {
     const installPath = resolveInstallPath(agent, {
       global: options.global === true
     });
+    if (!installPath) {
+      continue;
+    }
     const exists = await directoryExistsAsync(installPath);
     if (!exists) {
       continue;
@@ -1357,7 +1662,7 @@ async function collectInstalledSkills(detectedAgents, options) {
         name: skill.name,
         agentName: agent.name,
         installPath,
-        skillPath: join5(installPath, skill.name)
+        skillPath: join4(installPath, skill.name)
       });
     }
   }
@@ -1368,7 +1673,7 @@ async function selectSkillsToRemove(skillsToRemove, options) {
     const selected = skillsToRemove.filter((s) => s.name === options.skill);
     if (selected.length === 0) {
       log2.error(`Skill '${options.skill}' not found.`);
-      log2.info("Run 'braid-skills list' to see installed skills.");
+      log2.info("Run 'braid list' to see installed skills.");
       process6.exit(1);
     }
     return selected;
@@ -1408,7 +1713,14 @@ async function confirmRemoval(selectedCount, options) {
 async function removeSkill(skill, removeSpinner) {
   removeSpinner.start(`Removing ${skill.name} from ${skill.agentName}...`);
   try {
-    await rm(skill.skillPath, { recursive: true, force: true });
+    const resolvedSkillPath = resolve3(skill.skillPath);
+    const resolvedInstallPath = resolve3(skill.installPath);
+    if (!resolvedSkillPath.startsWith(`${resolvedInstallPath}/`)) {
+      removeSpinner.stop(`Unsafe path for ${skill.name}`);
+      log2.warn("  Skill path escapes install directory, skipping.");
+      return false;
+    }
+    await rm(resolvedSkillPath, { recursive: true, force: true });
     await removeFromMetadataAsync(skill.installPath, skill.name);
     removeSpinner.stop(`Removed ${skill.name} from ${skill.agentName}`);
     return true;
@@ -1435,7 +1747,7 @@ async function removeCommand(options) {
     );
     removeSpinner.stop(`Found ${skillsToRemove.length} installed skill(s)`);
     if (skillsToRemove.length === 0) {
-      log2.warn("No skills installed via braid-skills.");
+      log2.warn("No skills installed via braid.");
       return;
     }
     const selected = await selectSkillsToRemove(skillsToRemove, options);
@@ -1473,18 +1785,25 @@ import {
   outro as outro3,
   spinner as spinner4
 } from "@clack/prompts";
-import { Data as Data5, Effect as Effect6, pipe as pipe6 } from "effect";
-var UpdateError = class extends Data5.TaggedError("UpdateError") {
+import { Data as Data6, Effect as Effect7, pipe as pipe7 } from "effect";
+var UpdateError = class extends Data6.TaggedError("UpdateError") {
 };
-var UserCancelledError = class extends Data5.TaggedError("UserCancelledError") {
+var UserCancelledError = class extends Data6.TaggedError("UserCancelledError") {
 };
-var collectSourcesFromAgent = (agent, options, sourcesToUpdate) => Effect6.tryPromise({
+async function resolveValidInstallPath(agent, options) {
+  const installPath = resolveInstallPath(agent, {
+    global: options.global === true
+  });
+  if (!installPath) {
+    return null;
+  }
+  const exists = await directoryExistsAsync(installPath);
+  return exists ? installPath : null;
+}
+var collectSourcesFromAgent = (agent, options, sourcesToUpdate) => Effect7.tryPromise({
   try: async () => {
-    const installPath = resolveInstallPath(agent, {
-      global: options.global === true
-    });
-    const exists = await directoryExistsAsync(installPath);
-    if (!exists) {
+    const installPath = await resolveValidInstallPath(agent, options);
+    if (!installPath) {
       return;
     }
     const metadata = await readMetadataAsync(installPath);
@@ -1512,10 +1831,10 @@ var collectSourcesFromAgent = (agent, options, sourcesToUpdate) => Effect6.tryPr
   },
   catch: () => new UpdateError({ message: "Failed to collect sources" })
 });
-var collectSources = (detectedAgents, options) => pipe6(
-  Effect6.succeed(/* @__PURE__ */ new Map()),
-  Effect6.tap(
-    (sourcesToUpdate) => Effect6.forEach(
+var collectSources = (detectedAgents, options) => pipe7(
+  Effect7.succeed(/* @__PURE__ */ new Map()),
+  Effect7.tap(
+    (sourcesToUpdate) => Effect7.forEach(
       detectedAgents,
       (agent) => collectSourcesFromAgent(agent, options, sourcesToUpdate),
       { concurrency: 1 }
@@ -1524,9 +1843,9 @@ var collectSources = (detectedAgents, options) => pipe6(
 );
 var selectSources = (sourcesToUpdate, options) => {
   if (options.yes) {
-    return Effect6.succeed(sourcesToUpdate);
+    return Effect7.succeed(sourcesToUpdate);
   }
-  return Effect6.tryPromise({
+  return Effect7.tryPromise({
     try: async () => {
       const sources = Array.from(sourcesToUpdate.entries()).map(
         ([key, source]) => ({
@@ -1577,7 +1896,7 @@ var buildFetchOptionsForSource = (source, options) => {
   }
   return fetchOptions;
 };
-var updateAgentSkills = (agentId, agentName, installPath, response, serverUrl, updateSpinner) => Effect6.tryPromise({
+var updateAgentSkills = (agentId, agentName, installPath, response, serverUrl, updateSpinner) => Effect7.tryPromise({
   try: async () => {
     updateSpinner.start(`Updating ${agentName}...`);
     const result = await writeSkillsAsync(
@@ -1615,15 +1934,15 @@ var updateSource = (source, options, updateSpinner) => {
   const serverUrl = options.server ?? source.serverUrl;
   const fetchOptions = buildFetchOptionsForSource(source, options);
   if (fetchOptions === null) {
-    return Effect6.fail(
+    return Effect7.fail(
       new UpdateError({
-        message: "Skills installed with legacy metadata format. Please reinstall using 'braid-skills install --profile <name>' or 'braid-skills install --projects <names>'.",
+        message: "Skills installed with legacy metadata format. Please reinstall using 'braid install --profile <name>' or 'braid install --projects <names>'.",
         source: sourceDesc
       })
     );
   }
-  return pipe6(
-    Effect6.tryPromise({
+  return pipe7(
+    Effect7.tryPromise({
       try: async () => {
         updateSpinner.start(`Fetching latest skills from ${sourceDesc}...`);
         const response = await fetchSkillsAsync(fetchOptions);
@@ -1637,9 +1956,9 @@ var updateSource = (source, options, updateSpinner) => {
         source: sourceDesc
       })
     }),
-    Effect6.flatMap(
-      (response) => pipe6(
-        Effect6.forEach(
+    Effect7.flatMap(
+      (response) => pipe7(
+        Effect7.forEach(
           source.agents,
           ({ agentId, agentName, installPath }) => updateAgentSkills(
             agentId,
@@ -1651,7 +1970,7 @@ var updateSource = (source, options, updateSpinner) => {
           ),
           { concurrency: 1 }
         ),
-        Effect6.map((results) => ({
+        Effect7.map((results) => ({
           updated: results.reduce((sum, r) => sum + r.updated, 0),
           errors: results.reduce((sum, r) => sum + r.errors, 0)
         }))
@@ -1659,22 +1978,22 @@ var updateSource = (source, options, updateSpinner) => {
     )
   );
 };
-var updateAllSources = (sources, options, updateSpinner) => pipe6(
-  Effect6.forEach(
+var updateAllSources = (sources, options, updateSpinner) => pipe7(
+  Effect7.forEach(
     Array.from(sources.values()),
-    (source) => pipe6(
+    (source) => pipe7(
       updateSource(source, options, updateSpinner),
-      Effect6.catchAll((error) => {
+      Effect7.catchAll((error) => {
         updateSpinner.stop(
           `Failed to update from ${getSourceDesc(source)}`
         );
         log4.error(`  ${error.message}`);
-        return Effect6.succeed({ updated: 0, errors: 1 });
+        return Effect7.succeed({ updated: 0, errors: 1 });
       })
     ),
     { concurrency: 1 }
   ),
-  Effect6.map((results) => ({
+  Effect7.map((results) => ({
     totalUpdated: results.reduce((sum, r) => sum + r.updated, 0),
     totalErrors: results.reduce((sum, r) => sum + r.errors, 0)
   }))
@@ -1685,11 +2004,9 @@ var handleUpdateError = (error, updateSpinner) => {
     log4.warn(error.message);
     return;
   }
-  if (error.message === "No skills installed via braid-skills.") {
+  if (error.message === "No skills installed via braid.") {
     log4.warn(error.message);
-    log4.info(
-      "Run 'braid-skills install --profile <name>' to install skills first."
-    );
+    log4.info("Run 'braid install --profile <name>' to install skills first.");
     return;
   }
   log4.error(error.message);
@@ -1715,28 +2032,28 @@ var handleProgramExit = (result, updateSpinner) => {
 async function updateCommand(options) {
   const updateSpinner = spinner4();
   updateSpinner.start("Scanning for installed skills...");
-  const program2 = pipe6(
-    Effect6.tryPromise({
+  const program2 = pipe7(
+    Effect7.tryPromise({
       try: () => detectAgentsAsync(),
       catch: () => new UpdateError({ message: "Failed to detect agents" })
     }),
-    Effect6.filterOrFail(
+    Effect7.filterOrFail(
       (agents) => agents.length > 0,
       () => new UpdateError({ message: "No AI coding agents detected." })
     ),
-    Effect6.flatMap((detectedAgents) => collectSources(detectedAgents, options)),
-    Effect6.tap((sources) => {
+    Effect7.flatMap((detectedAgents) => collectSources(detectedAgents, options)),
+    Effect7.tap((sources) => {
       updateSpinner.stop(`Found ${sources.size} source(s) to update`);
     }),
-    Effect6.filterOrFail(
+    Effect7.filterOrFail(
       (sources) => sources.size > 0,
-      () => new UpdateError({ message: "No skills installed via braid-skills." })
+      () => new UpdateError({ message: "No skills installed via braid." })
     ),
-    Effect6.flatMap((sources) => selectSources(sources, options)),
-    Effect6.flatMap(
+    Effect7.flatMap((sources) => selectSources(sources, options)),
+    Effect7.flatMap(
       (selectedSources) => updateAllSources(selectedSources, options, updateSpinner)
     ),
-    Effect6.tap(({ totalUpdated, totalErrors }) => {
+    Effect7.tap(({ totalUpdated, totalErrors }) => {
       if (totalErrors > 0) {
         outro3(`Updated ${totalUpdated} skills with ${totalErrors} errors.`);
       } else {
@@ -1744,14 +2061,14 @@ async function updateCommand(options) {
       }
     })
   );
-  const result = await Effect6.runPromiseExit(program2);
+  const result = await Effect7.runPromiseExit(program2);
   handleProgramExit(result, updateSpinner);
 }
 
 // src/index.ts
 var program = new Command();
-program.name("braid-skills").description(
-  "Install Braid rules as agent skills to your local development environment"
+program.name("braid").description(
+  "Install Braid prompts as agent skills to your local development environment"
 ).version("0.1.0");
 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);
@@ -1765,11 +2082,11 @@ program.command("install").alias("add").description("Install skills from a profi
   "Comma-separated personal project IDs to install from"
 ).option(
   "--include-user-globals",
-  "Include user's personal global rules (default: true)"
-).option("--no-include-user-globals", "Exclude user's personal global rules").option(
+  "Include user's personal global prompts (default: true)"
+).option("--no-include-user-globals", "Exclude user's personal global prompts").option(
   "--include-org-globals",
-  "Include organization's global rules (default: true)"
-).option("--no-include-org-globals", "Exclude organization's global rules").option(
+  "Include organization's global prompts (default: true)"
+).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);