wave-agent-sdk 0.17.5 → 0.17.6

package/dist/utils/customCommands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"customCommands.d.ts","sourceRoot":"","sources":["../../src/utils/customCommands.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAK5D;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAwC3E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAkB7E"}
+{"version":3,"file":"customCommands.d.ts","sourceRoot":"","sources":["../../src/utils/customCommands.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAK5D;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAwC3E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAuB7E"}

package/dist/utils/customCommands.js

@@ -60,16 +60,18 @@ export function scanCommandsDirectory(dirPath) {
  * Load all custom slash commands from both project and user directories
  */
 export function loadCustomSlashCommands(workdir) {
-    const projectCommands = scanCommandsDirectory(getProjectCommandsDir(workdir));
-    const userCommands = scanCommandsDirectory(getUserCommandsDir());
-    // Project commands take precedence over user commands with the same name
+    const userClaudeCommands = scanCommandsDirectory(join(homedir(), ".claude", "commands"));
+    const userWaveCommands = scanCommandsDirectory(getUserCommandsDir());
+    const projectClaudeCommands = scanCommandsDirectory(join(workdir, ".claude", "commands"));
+    const projectWaveCommands = scanCommandsDirectory(getProjectCommandsDir(workdir));
     const commandMap = new Map();
-    // Add user commands first
-    for (const command of userCommands) {
-        commandMap.set(command.id, command);
-    }
-    // Add project commands (will overwrite user commands with same name)
-    for (const command of projectCommands) {
+    // Write in priority order: lowest first, highest last (overwrites)
+    for (const command of [
+        ...userClaudeCommands,
+        ...userWaveCommands,
+        ...projectClaudeCommands,
+        ...projectWaveCommands,
+    ]) {
         commandMap.set(command.id, command);
     }
     return Array.from(commandMap.values());

package/dist/utils/skillParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"skillParser.d.ts","sourceRoot":"","sources":["../../src/utils/skillParser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAEjB,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,iBAAsB,GAC9B,eAAe,CAgGjB;AAyDD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,EAAE,CAwCvE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOtD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAa5E"}
+{"version":3,"file":"skillParser.d.ts","sourceRoot":"","sources":["../../src/utils/skillParser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EAEjB,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B;;GAEG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,iBAAsB,GAC9B,eAAe,CAkGjB;AAyDD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,EAAE,CAwCvE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOtD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAa5E"}

package/dist/utils/skillParser.js

@@ -36,7 +36,9 @@ export function parseSkillFile(filePath, options = {}) {
         // Determine skill type and path
         const skillPath = basePath || dirname(filePath);
         const skillType = skillPath.includes("/.wave/skills") ||
-            skillPath.includes("\\.wave\\skills")
+            skillPath.includes("\\.wave\\skills") ||
+            skillPath.includes("/.claude/skills") ||
+            skillPath.includes("\\.claude\\skills")
             ? "project"
             : "personal";
         // Extract allowed tools

package/dist/utils/subagentParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagentParser.d.ts","sourceRoot":"","sources":["../../src/utils/subagentParser.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAmKD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,MAAM,GACjB,qBAAqB,CAEvB;AAqCD;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAsBlC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAGvC"}
+{"version":3,"file":"subagentParser.d.ts","sourceRoot":"","sources":["../../src/utils/subagentParser.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAmKD;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EACf,UAAU,EAAE,MAAM,GACjB,qBAAqB,CAEvB;AAqCD;;GAEG;AACH,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAoClC;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAGvC"}

package/dist/utils/subagentParser.js

@@ -160,17 +160,28 @@ function scanSubagentDirectory(dirPath, scope) {
  * Load all subagent configurations from project and user directories, plus built-in subagents
  */
 export async function loadSubagentConfigurations(workdir) {
-    const projectDir = join(workdir, ".wave", "agents");
-    const userDir = join(process.env.HOME || "~", ".wave", "agents");
+    const projectWaveDir = join(workdir, ".wave", "agents");
+    const projectClaudeDir = join(workdir, ".claude", "agents");
+    const userWaveDir = join(process.env.HOME || "~", ".wave", "agents");
+    const userClaudeDir = join(process.env.HOME || "~", ".claude", "agents");
     const builtinDir = getBuiltinSubagentsDir();
     // Load configurations from all sources
     const builtinConfigs = scanSubagentDirectory(builtinDir, "builtin");
-    const projectConfigs = scanSubagentDirectory(projectDir, "project");
-    const userConfigs = scanSubagentDirectory(userDir, "user");
-    // Merge configurations, with project configs taking highest precedence
+    const userClaudeConfigs = scanSubagentDirectory(userClaudeDir, "user");
+    const userWaveConfigs = scanSubagentDirectory(userWaveDir, "user");
+    const projectClaudeConfigs = scanSubagentDirectory(projectClaudeDir, "project");
+    const projectWaveConfigs = scanSubagentDirectory(projectWaveDir, "project");
+    // Merge configurations, with .wave taking priority over .claude
     const configMap = new Map();
-    // Process in reverse priority order (built-in first, then user, then project)
-    for (const config of [...builtinConfigs, ...userConfigs, ...projectConfigs]) {
+    // Merge order: builtin → userClaude → userWave → projectClaude → projectWave
+    // Later writes override earlier ones, so .wave takes priority over .claude
+    for (const config of [
+        ...builtinConfigs,
+        ...userClaudeConfigs,
+        ...userWaveConfigs,
+        ...projectClaudeConfigs,
+        ...projectWaveConfigs,
+    ]) {
         configMap.set(config.name, config);
     }
     return Array.from(configMap.values()).sort((a, b) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wave-agent-sdk",
-  "version": "0.17.5",
+  "version": "0.17.6",
   "description": "SDK for building AI-powered development tools and agents",
   "keywords": [
     "ai",

package/src/managers/MemoryRuleManager.ts

@@ -39,23 +39,26 @@ export class MemoryRuleManager {
    * Scans .wave/rules and ~/.wave/rules for memory rule files.
    */
   async discoverRules(): Promise<void> {
-    const projectRulesDir = path.join(this.workdir, ".wave", "rules");
-    const userRulesDir = path.join(os.homedir(), ".wave", "rules");
+    const projectWaveRulesDir = path.join(this.workdir, ".wave", "rules");
+    const projectClaudeRulesDir = path.join(this.workdir, ".claude", "rules");
+    const userWaveRulesDir = path.join(os.homedir(), ".wave", "rules");
+    const userClaudeRulesDir = path.join(os.homedir(), ".claude", "rules");
 
     logger.debug(`Scanning for modular memory rules...`);
-    logger.debug(`  User rules directory: ${userRulesDir}`);
-    logger.debug(`  Project rules directory: ${projectRulesDir}`);
+    logger.debug(`  User rules directory: ${userWaveRulesDir}`);
+    logger.debug(`  Project rules directory: ${projectWaveRulesDir}`);
 
     const newRules: Record<string, MemoryRule> = {};
 
-    // Discover user rules first, then project rules so project rules can override if needed
-    // (though IDs are based on file path, so they shouldn't collide unless same path)
-    await this.scanDirectory(userRulesDir, "user", newRules);
-    await this.scanDirectory(projectRulesDir, "project", newRules);
+    // Scan order: userClaude → userWave → projectClaude → projectWave
+    // Later writes override, so .wave takes priority over .claude
+    await this.scanDirectory(userClaudeRulesDir, "user", newRules);
+    await this.scanDirectory(userWaveRulesDir, "user", newRules);
+    await this.scanDirectory(projectClaudeRulesDir, "project", newRules);
+    await this.scanDirectory(projectWaveRulesDir, "project", newRules);
 
     this.state.rules = newRules;
     const ruleCount = Object.keys(newRules).length;
-    // Removed verbose logging of all discovered rules
     logger.debug(`Discovered ${ruleCount} modular memory rules`);
   }
 
@@ -124,11 +127,23 @@ export class MemoryRuleManager {
     try {
       const content = await fs.readFile(filePath, "utf-8");
       const rule = this.service.parseRule(content, filePath, source);
-      // Use relative path from rules root as ID to allow project rules to override user rules
-      const rulesRoot =
-        source === "project"
-          ? path.join(this.workdir, ".wave", "rules")
-          : path.join(os.homedir(), ".wave", "rules");
+
+      // Determine rulesRoot dynamically based on actual file path
+      let rulesRoot: string;
+      if (source === "project") {
+        if (filePath.includes(path.join(".claude", "rules"))) {
+          rulesRoot = path.join(this.workdir, ".claude", "rules");
+        } else {
+          rulesRoot = path.join(this.workdir, ".wave", "rules");
+        }
+      } else {
+        if (filePath.includes(path.join(".claude", "rules"))) {
+          rulesRoot = path.join(os.homedir(), ".claude", "rules");
+        } else {
+          rulesRoot = path.join(os.homedir(), ".wave", "rules");
+        }
+      }
+
       const relativeId = path.relative(rulesRoot, filePath);
       rule.id = relativeId;
       registry[rule.id] = rule;

package/src/managers/hookManager.ts

@@ -183,16 +183,21 @@ export class HookManager {
                 env: {
                   ...("env" in context ? (context.env ?? {}) : {}),
                   WAVE_PLUGIN_ROOT: hookCommand.pluginRoot,
+                  CLAUDE_PLUGIN_ROOT: hookCommand.pluginRoot,
                 },
               }
             : context;
 
-          // Substitute ${WAVE_PLUGIN_ROOT} in the command string (same pattern as Claude Code)
+          // Substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT} in the command string
           if (hookCommand.pluginRoot) {
             command = command.replace(
               /\$\{WAVE_PLUGIN_ROOT\}/g,
               hookCommand.pluginRoot,
             );
+            command = command.replace(
+              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+              hookCommand.pluginRoot,
+            );
           }
 
           if (hookCommand.async) {

package/src/managers/lspManager.ts

@@ -92,22 +92,40 @@ export class LspManager implements ILspManager {
     try {
       const env = { ...process.env, ...config.env };
 
-      // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} in command/args/env
+      // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
       let command = config.command;
       let args = config.args || [];
       if (config.pluginRoot) {
         env.WAVE_PLUGIN_ROOT = config.pluginRoot;
+        env.CLAUDE_PLUGIN_ROOT = config.pluginRoot;
         command = command.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, config.pluginRoot);
-        args = args.map((arg) =>
-          arg.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, config.pluginRoot!),
+        command = command.replace(
+          /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+          config.pluginRoot,
         );
-        // Also expand WAVE_PLUGIN_ROOT in user-provided env values
+        args = args.map((arg) => {
+          let result = arg.replace(
+            /\$\{WAVE_PLUGIN_ROOT\}/g,
+            config.pluginRoot!,
+          );
+          result = result.replace(
+            /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+            config.pluginRoot!,
+          );
+          return result;
+        });
+        // Also expand plugin root in user-provided env values
         if (config.env) {
           for (const [key, value] of Object.entries(config.env)) {
-            env[key] = value.replace(
+            let expanded = value.replace(
               /\$\{WAVE_PLUGIN_ROOT\}/g,
               config.pluginRoot!,
             );
+            expanded = expanded.replace(
+              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+              config.pluginRoot!,
+            );
+            env[key] = expanded;
           }
         }
       }

package/src/managers/mcpManager.ts

@@ -40,7 +40,7 @@ export interface McpManagerOptions {
  * Expand environment variables in a string value.
  * Supports ${VAR} and ${VAR:-default} patterns.
  */
-const WAVE_TEMPLATE_VARS = ["WAVE_PLUGIN_ROOT"];
+const WAVE_TEMPLATE_VARS = ["WAVE_PLUGIN_ROOT", "CLAUDE_PLUGIN_ROOT"];
 
 export function expandEnvVars(value: string): string {
   return value.replace(/\$\{([^}]+)\}/g, (_match, expr: string) => {
@@ -440,25 +440,42 @@ export class McpManager {
           ...(server.config.env || {}),
         };
 
-        // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} in command/args/env
-        // (same pattern as Claude Code's substitutePluginVariables)
+        // For plugin servers, substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
         let command = server.config.command;
         let args = server.config.args || [];
         if (server.config.pluginRoot) {
           env.WAVE_PLUGIN_ROOT = server.config.pluginRoot;
+          env.CLAUDE_PLUGIN_ROOT = server.config.pluginRoot;
           command = command.replace(
             /\$\{WAVE_PLUGIN_ROOT\}/g,
             server.config.pluginRoot,
           );
-          args = args.map((arg) =>
-            arg.replace(/\$\{WAVE_PLUGIN_ROOT\}/g, server.config.pluginRoot!),
+          command = command.replace(
+            /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+            server.config.pluginRoot,
           );
-          // Also expand WAVE_PLUGIN_ROOT in user-provided env values
+          args = args.map((arg) => {
+            let result = arg.replace(
+              /\$\{WAVE_PLUGIN_ROOT\}/g,
+              server.config.pluginRoot!,
+            );
+            result = result.replace(
+              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+              server.config.pluginRoot!,
+            );
+            return result;
+          });
+          // Also expand plugin root in user-provided env values
           for (const [key, value] of Object.entries(server.config.env || {})) {
-            env[key] = value.replace(
+            let expanded = value.replace(
               /\$\{WAVE_PLUGIN_ROOT\}/g,
               server.config.pluginRoot!,
             );
+            expanded = expanded.replace(
+              /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+              server.config.pluginRoot!,
+            );
+            env[key] = expanded;
           }
         }
         transport = new StdioClientTransport({

package/src/managers/skillManager.ts

@@ -29,6 +29,7 @@ import { logger } from "../utils/globalLogger.js";
  */
 export class SkillManager extends EventEmitter {
   private personalSkillsPath: string;
+  private personalClaudeSkillsPath: string;
   private scanTimeout: number;
   private workdir: string;
 
@@ -47,6 +48,8 @@ export class SkillManager extends EventEmitter {
     super();
     this.personalSkillsPath =
       options.personalSkillsPath || join(homedir(), ".wave", "skills");
+    this.personalClaudeSkillsPath =
+      options.personalClaudeSkillsPath || join(homedir(), ".claude", "skills");
     this.scanTimeout = options.scanTimeout || 5000;
     this.workdir = options.workdir || process.cwd();
     this.watchEnabled = options.watch ?? false;
@@ -127,7 +130,9 @@ export class SkillManager extends EventEmitter {
 
     const pathsToWatch = [
       this.personalSkillsPath,
+      this.personalClaudeSkillsPath,
       join(this.workdir, ".wave", "skills"),
+      join(this.workdir, ".claude", "skills"),
     ];
 
     logger?.debug(`Setting up skill watcher for: ${pathsToWatch.join(", ")}`);
@@ -220,6 +225,11 @@ export class SkillManager extends EventEmitter {
       "builtin",
     );
 
+    const personalClaudeCollection = await this.discoverSkillCollection(
+      this.personalClaudeSkillsPath,
+      "personal",
+    );
+
     const personalCollection = await this.discoverSkillCollection(
       this.personalSkillsPath,
       "personal",
@@ -232,10 +242,14 @@ export class SkillManager extends EventEmitter {
 
     return {
       builtinSkills: builtinCollection.skills,
-      personalSkills: personalCollection.skills,
+      personalSkills: new Map([
+        ...personalClaudeCollection.skills,
+        ...personalCollection.skills, // .wave overrides .claude
+      ]),
       projectSkills: projectCollection.skills,
       errors: [
         ...builtinCollection.errors,
+        ...personalClaudeCollection.errors,
         ...personalCollection.errors,
         ...projectCollection.errors,
       ],
@@ -256,77 +270,88 @@ export class SkillManager extends EventEmitter {
       errors: [],
     };
 
-    let skillsPath: string;
-    if (type === "personal") {
-      skillsPath = basePath;
-    } else if (type === "builtin") {
-      skillsPath = basePath;
+    if (type === "project") {
+      // Scan .claude/skills first, then .wave/skills (wave overrides)
+      const claudePath = join(basePath, ".claude", "skills");
+      const wavePath = join(basePath, ".wave", "skills");
+      await this.scanSkillPath(claudePath, collection);
+      await this.scanSkillPath(wavePath, collection);
     } else {
-      skillsPath = join(basePath, ".wave", "skills");
+      await this.scanSkillPath(basePath, collection);
     }
 
+    return collection;
+  }
+
+  private async scanSkillPath(
+    skillsPath: string,
+    collection: SkillCollection,
+  ): Promise<void> {
     try {
       const skillDirs = await this.findSkillDirectories(skillsPath);
       logger?.debug(
         `Found ${skillDirs.length} potential skill directories in ${skillsPath}`,
       );
+      await this.processSkillDirs(skillDirs, collection);
+    } catch (error) {
+      logger?.debug(
+        `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
 
-      for (const skillDir of skillDirs) {
-        try {
-          const skillFilePath = join(skillDir, "SKILL.md");
+  private async processSkillDirs(
+    skillDirs: string[],
+    collection: SkillCollection,
+  ): Promise<void> {
+    for (const skillDir of skillDirs) {
+      try {
+        const skillFilePath = join(skillDir, "SKILL.md");
 
-          // Check if SKILL.md exists
-          try {
-            await stat(skillFilePath);
-          } catch {
-            continue; // Skip directories without SKILL.md
-          }
-
-          const parsed = parseSkillFile(skillFilePath, {
-            basePath: skillDir,
-            validateMetadata: true,
-          });
+        // Check if SKILL.md exists
+        try {
+          await stat(skillFilePath);
+        } catch {
+          continue; // Skip directories without SKILL.md
+        }
 
-          if (parsed.isValid) {
-            // Override the skill type with the collection type
-            const skillMetadata: SkillMetadata = {
-              ...parsed.skillMetadata,
-              type,
-            };
-
-            // Create full skill object with content
-            const skill: Skill = {
-              ...skillMetadata,
-              content: parsed.content,
-              frontmatter: parsed.frontmatter,
-              isValid: parsed.isValid,
-              errors: parsed.validationErrors,
-            };
-
-            collection.skills.set(skillMetadata.name, skillMetadata);
-            // Store the full skill content in the manager's skillContent map
-            this.skillContent.set(skillMetadata.name, skill);
-          } else {
-            collection.errors.push({
-              skillPath: skillDir,
-              message: parsed.validationErrors.join("; "),
-            });
-          }
-        } catch (error) {
+        const parsed = parseSkillFile(skillFilePath, {
+          basePath: skillDir,
+          validateMetadata: true,
+        });
+
+        if (parsed.isValid) {
+          // Override the skill type with the collection type
+          const skillMetadata: SkillMetadata = {
+            ...parsed.skillMetadata,
+            type: collection.type,
+          };
+
+          // Create full skill object with content
+          const skill: Skill = {
+            ...skillMetadata,
+            content: parsed.content,
+            frontmatter: parsed.frontmatter,
+            isValid: parsed.isValid,
+            errors: parsed.validationErrors,
+          };
+
+          collection.skills.set(skillMetadata.name, skillMetadata);
+          // Store the full skill content in the manager's skillContent map
+          this.skillContent.set(skillMetadata.name, skill);
+        } else {
           collection.errors.push({
             skillPath: skillDir,
-            message: `Failed to process skill: ${error instanceof Error ? error.message : String(error)}`,
+            message: parsed.validationErrors.join("; "),
           });
         }
+      } catch (error) {
+        collection.errors.push({
+          skillPath: skillDir,
+          message: `Failed to process skill: ${error instanceof Error ? error.message : String(error)}`,
+        });
       }
-    } catch (error) {
-      logger?.debug(
-        `Could not scan ${skillsPath}: ${error instanceof Error ? error.message : String(error)}`,
-      );
-      // Not an error - the directory might not exist yet
     }
-
-    return collection;
   }
 
   /**
@@ -450,15 +475,23 @@ export class SkillManager extends EventEmitter {
     // 1. Substitute parameters ($1, $ARGUMENTS, etc.)
     mainContent = substituteCommandParameters(mainContent, argsString);
 
-    // 2. Substitute ${WAVE_SKILL_DIR} with the skill's directory path
+    // 2. Substitute ${WAVE_SKILL_DIR} and ${CLAUDE_SKILL_DIR}
     mainContent = mainContent.replace(/\$\{WAVE_SKILL_DIR\}/g, skill.skillPath);
+    mainContent = mainContent.replace(
+      /\$\{CLAUDE_SKILL_DIR\}/g,
+      skill.skillPath,
+    );
 
-    // 3. Substitute ${WAVE_PLUGIN_ROOT} with the skill's plugin root path
+    // 3. Substitute ${WAVE_PLUGIN_ROOT} and ${CLAUDE_PLUGIN_ROOT}
     if (skill.pluginRoot) {
       mainContent = mainContent.replace(
         /\$\{WAVE_PLUGIN_ROOT\}/g,
         skill.pluginRoot,
       );
+      mainContent = mainContent.replace(
+        /\$\{CLAUDE_PLUGIN_ROOT\}/g,
+        skill.pluginRoot,
+      );
     }
 
     return skillPath + mainContent;

package/src/services/MarketplaceService.ts

@@ -390,13 +390,21 @@ export class MarketplaceService {
   async loadMarketplaceManifest(
     marketplacePath: string,
   ): Promise<MarketplaceManifest> {
-    const manifestPath = path.join(
+    let manifestPath = path.join(
       marketplacePath,
       ".wave-plugin",
       "marketplace.json",
     );
     if (!existsSync(manifestPath)) {
-      throw new Error(`Marketplace manifest not found at ${manifestPath}`);
+      // Fallback to .claude-plugin/marketplace.json
+      manifestPath = path.join(
+        marketplacePath,
+        ".claude-plugin",
+        "marketplace.json",
+      );
+      if (!existsSync(manifestPath)) {
+        throw new Error(`Marketplace manifest not found at ${manifestPath}`);
+      }
     }
     const content = await fs.readFile(manifestPath, "utf-8");
     const manifest = JSON.parse(content);
@@ -899,13 +907,23 @@ export class MarketplaceService {
           pluginSrcPath = path.resolve(marketplacePath, pluginEntry.source);
         }
 
-        const pluginManifestPath = path.join(
+        let pluginManifestPath = path.join(
           pluginSrcPath,
           ".wave-plugin",
           "plugin.json",
         );
         if (!existsSync(pluginManifestPath)) {
-          throw new Error(`Plugin manifest not found at ${pluginManifestPath}`);
+          // Fallback to .claude-plugin/plugin.json
+          pluginManifestPath = path.join(
+            pluginSrcPath,
+            ".claude-plugin",
+            "plugin.json",
+          );
+          if (!existsSync(pluginManifestPath)) {
+            throw new Error(
+              `Plugin manifest not found at ${pluginManifestPath}`,
+            );
+          }
         }
 
         const pluginManifestContent = await fs.readFile(

package/src/services/memory.ts

@@ -130,6 +130,27 @@ export class MemoryService {
         userMemoryFile: USER_MEMORY_FILE,
         contentLength: content.length,
       });
+
+      // If the file is still the default empty template, fallback to ~/.claude/AGENTS.md
+      const defaultTemplate =
+        "# User Memory\n\nThis is the user-level memory file, recording important information and context across projects.\n\n";
+      if (content === defaultTemplate) {
+        const claudeMemoryPath = path.join(homedir(), ".claude", "AGENTS.md");
+        try {
+          const claudeContent = await fs.readFile(claudeMemoryPath, "utf-8");
+          logger.debug(
+            "User memory content read from ~/.claude/AGENTS.md fallback",
+            {
+              claudeMemoryPath,
+              contentLength: claudeContent.length,
+            },
+          );
+          return claudeContent;
+        } catch {
+          // CLAUDE.md doesn't exist or can't be read, return the default template
+        }
+      }
+
       return content;
     } catch (error) {
       logger.error("Failed to read user memory:", error);
@@ -139,8 +160,6 @@ export class MemoryService {
 
   async readMemoryFile(workdir: string): Promise<string> {
     const memoryFilePath = path.join(workdir, "AGENTS.md");
-
-    // Direct file access
     try {
       const content = await fs.readFile(memoryFilePath, "utf-8");
       logger.debug("Memory file read successfully via direct file access", {
@@ -150,10 +169,28 @@ export class MemoryService {
       return content;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        logger.debug("Memory file does not exist, returning empty content", {
-          memoryFilePath,
-        });
-        return "";
+        // Fallback to CLAUDE.md
+        const claudeMemoryPath = path.join(workdir, "CLAUDE.md");
+        try {
+          const content = await fs.readFile(claudeMemoryPath, "utf-8");
+          logger.debug("Memory file read from CLAUDE.md fallback", {
+            memoryFilePath: claudeMemoryPath,
+            contentLength: content.length,
+          });
+          return content;
+        } catch (claudeError) {
+          if ((claudeError as NodeJS.ErrnoException).code === "ENOENT") {
+            logger.debug("Neither AGENTS.md nor CLAUDE.md found", {
+              memoryFilePath,
+            });
+            return "";
+          }
+          logger.error("Failed to read CLAUDE.md fallback", {
+            memoryFilePath: claudeMemoryPath,
+            error: claudeError,
+          });
+          return "";
+        }
       }
       logger.error("Failed to read memory file", { memoryFilePath, error });
       return "";