wave-agent-sdk 0.17.5 → 0.17.7

package/src/prompts/planModeReminders.ts

@@ -106,26 +106,14 @@ This is critical - your turn should only end with either using the ${ASK_USER_QU
 NOTE: At any point in time through this workflow you should feel free to ask the user questions or clarifications using the ${ASK_USER_QUESTION_TOOL_NAME} tool. Don't make large assumptions about user intent. The goal is to present a well researched plan to the user, and tie any loose ends before implementation begins.`);
 }
 
-export function buildPlanModeSparseReminder(planFilePath: string): string {
-  return wrapInSystemReminder(
-    `Plan mode still active (see full instructions earlier in conversation). Read-only except plan file at ${planFilePath}. End turns with ${ASK_USER_QUESTION_TOOL_NAME} or ${EXIT_PLAN_MODE_TOOL_NAME}.`,
-  );
-}
-
 export function buildPlanModeReEntryReminder(planFilePath: string): string {
   return wrapInSystemReminder(`## Re-entering Plan Mode
 
-You are returning to plan mode after having previously exited it. A plan file exists at ${planFilePath} from your previous planning session.
+You are returning to plan mode. A plan file exists at ${planFilePath} from your previous session.
 
-**Before proceeding with any new planning, you should:**
 1. Read the existing plan file to understand what was previously planned
-2. Evaluate the user's current request against that plan
-3. Decide how to proceed:
-   - **Different task**: If the user's request is for a different task—even if it's similar or related—start fresh by overwriting the existing plan
-   - **Same task, continuing**: If this is explicitly a continuation or refinement of the exact same task, modify the existing plan while cleaning up outdated or irrelevant sections
-4. Continue on with the plan process and most importantly you should always edit the plan file one way or the other before calling ${EXIT_PLAN_MODE_TOOL_NAME}
-
-Treat this as a fresh planning session. Do not assume the existing plan is relevant without evaluating it first.`);
+2. Decide: if the user's request is a different task, start fresh by overwriting the plan; if it's a continuation, modify the existing plan
+3. Edit the plan file as needed, then call ${EXIT_PLAN_MODE_TOOL_NAME}`);
 }
 
 export function buildExitedPlanModeReminder(

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 "";

package/src/services/pluginLoader.ts

@@ -23,11 +23,13 @@ export class PluginLoader {
    */
   static async loadManifest(pluginPath: string): Promise<PluginManifest> {
     const dotWavePluginPath = path.join(pluginPath, ".wave-plugin");
-    const manifestPath = path.join(dotWavePluginPath, "plugin.json");
 
-    // T018: Ensure plugin.json is the only file in .wave-plugin/
+    // Check if .wave-plugin/ directory exists
+    let wavePluginDirExists = false;
     try {
       const entries = await fs.readdir(dotWavePluginPath);
+      wavePluginDirExists = true;
+      // T018: Ensure plugin.json is the only file in .wave-plugin/
       const misplaced = entries.filter((e) => e !== "plugin.json");
       if (misplaced.length > 0) {
         throw new Error(
@@ -39,15 +41,39 @@ export class PluginLoader {
         error instanceof Error &&
         (error as { code?: string }).code === "ENOENT"
       ) {
+        // .wave-plugin/ doesn't exist, will try .claude-plugin/ fallback below
+      } else {
+        throw error;
+      }
+    }
+
+    if (wavePluginDirExists) {
+      const manifestPath = path.join(dotWavePluginPath, "plugin.json");
+      try {
+        const content = await fs.readFile(manifestPath, "utf-8");
+        const manifest = JSON.parse(content) as PluginManifest;
+        this.validateManifest(manifest);
+        return manifest;
+      } catch (error) {
+        if (
+          error instanceof Error &&
+          (error as { code?: string }).code === "ENOENT"
+        ) {
+          throw new Error(`Plugin manifest not found at ${manifestPath}`);
+        }
         throw new Error(
-          `Plugin manifest directory not found at ${dotWavePluginPath}`,
+          `Failed to load plugin manifest at ${manifestPath}: ${
+            error instanceof Error ? error.message : String(error)
+          }`,
         );
       }
-      throw error;
     }
 
+    // Fallback to .claude-plugin/
+    const dotClaudePluginPath = path.join(pluginPath, ".claude-plugin");
+    const claudeManifestPath = path.join(dotClaudePluginPath, "plugin.json");
     try {
-      const content = await fs.readFile(manifestPath, "utf-8");
+      const content = await fs.readFile(claudeManifestPath, "utf-8");
       const manifest = JSON.parse(content) as PluginManifest;
       this.validateManifest(manifest);
       return manifest;
@@ -56,10 +82,12 @@ export class PluginLoader {
         error instanceof Error &&
         (error as { code?: string }).code === "ENOENT"
       ) {
-        throw new Error(`Plugin manifest not found at ${manifestPath}`);
+        throw new Error(
+          `Plugin manifest not found at ${dotWavePluginPath} or ${dotClaudePluginPath}`,
+        );
       }
       throw new Error(
-        `Failed to load plugin manifest at ${manifestPath}: ${
+        `Failed to load plugin manifest at ${claudeManifestPath}: ${
           error instanceof Error ? error.message : String(error)
         }`,
       );

package/src/types/skills.ts

@@ -73,6 +73,7 @@ export interface SkillToolArgs {
 
 export interface SkillManagerOptions {
   personalSkillsPath?: string;
+  personalClaudeSkillsPath?: string;
   scanTimeout?: number;
   workdir?: string;
   watch?: boolean;

package/src/utils/customCommands.ts

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

package/src/utils/skillParser.ts

@@ -55,7 +55,9 @@ export function parseSkillFile(
     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";
 

package/src/utils/subagentParser.ts

@@ -230,20 +230,34 @@ function scanSubagentDirectory(
 export async function loadSubagentConfigurations(
   workdir: string,
 ): Promise<SubagentConfiguration[]> {
-  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<string, SubagentConfiguration>();
 
-  // 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);
   }