compound-workflow 1.7.2 → 1.8.0

package/.cursor-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "compound-workflow",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "Clarify -> plan -> execute -> verify -> capture workflow for Cursor",
   "author": {
     "name": "Compound Workflow"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compound-workflow",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "Clarify → plan → execute → verify → capture. One Install action for Cursor, Claude, and OpenCode.",
   "license": "MIT",
   "repository": {

package/scripts/install-cli.mjs

@@ -9,8 +9,12 @@
  * - Commands: add/remove .md under src/.agents/commands/ (frontmatter: invocation, name, description).
  *   Registry (src/.agents/registry.json) + generate-platform-artifacts → opencode.managed.json → install.
  * - Agents: add/remove .md under src/.agents/agents/ (frontmatter: name, description). Same pipeline.
- * - Skills: add/remove dir src/.agents/skills/<name>/SKILL.md. OpenCode uses skills path; install syncs
- *   each skill into .cursor/skills/ (symlinks) so Cursor discovers them. Prune removes stale symlinks.
+ * - Skills: add/remove dir src/.agents/skills/<name>/SKILL.md. OpenCode uses skills path.
+ *
+ * PLATFORM STRATEGY:
+ * - Cursor: copies files into .cursor/skills/, .cursor/commands/, .cursor/agents/ for native discovery.
+ * - Claude Code: marketplace flow via .claude-plugin/ + project .claude/settings.json.
+ * - OpenCode: opencode.json with paths into package source.
  * Run install (or npm install compound-workflow) after any change; no other registration needed.
  */
 import fs from "node:fs";
@@ -25,31 +29,26 @@ function usage(exitCode = 0) {
   const msg = `
 Usage:
   (automatic) npm install compound-workflow   # runs install via postinstall; no npx needed
-  (manual)    npx compound-workflow install [--root <projectDir>] [--dry-run] [--no-config] [--no-register-cursor] [--register-cursor]
+  (manual)    npx compound-workflow install [--root <projectDir>] [--dry-run] [--no-config]
 
 Install writes opencode.json (from package), merges AGENTS.md, creates standard
-docs/todos directories, and prompts for Repo Config Block (unless --no-config).
-When Cursor is detected (~/.cursor), registers the plugin so skills/commands appear.
+docs/todos directories, copies skills/commands/agents into .cursor/ for Cursor,
+and registers the Claude Code plugin (project-scoped).
 
   --root <dir>            Project directory (default: cwd)
   --dry-run               Print planned changes only
   --no-config             Skip Repo Config Block reminder
-  --no-register-cursor    Do not register plugin with Cursor (skip apply to ~/.claude/)
-  --register-cursor       Force registration with Cursor even if ~/.cursor not found
 `;
   (exitCode === 0 ? console.log : console.error)(msg.trimStart());
   process.exit(exitCode);
 }
 
 function parseArgs(argv) {
-  const out = { root: process.cwd(), dryRun: false, noConfig: false, noRegisterCursor: false, registerCursor: false, verify: false };
+  const out = { root: process.cwd(), dryRun: false, noConfig: false };
   for (let i = 2; i < argv.length; i++) {
     const arg = argv[i];
     if (arg === "--dry-run") out.dryRun = true;
     else if (arg === "--no-config") out.noConfig = true;
-    else if (arg === "--no-register-cursor") out.noRegisterCursor = true;
-    else if (arg === "--register-cursor") out.registerCursor = true;
-    else if (arg === "--verify") out.verify = true;
     else if (arg === "--root") {
       const value = argv[i + 1];
       if (!value) usage(1);
@@ -342,13 +341,12 @@ function writePluginManifests(targetRoot, dryRun, isSelfInstall) {
   const claudeManifest = readJsonMaybe(claudeSrc);
   if (!cursorManifest || !claudeManifest) return;
 
-  // Cursor supports full manifest with commands/agents/skills path overrides.
-  // For commands/agents, use .cursor/ directories where symlinks are created
-  // so Cursor can discover them properly. Skills still use source path.
+  // All Cursor paths point directly at the package source — no symlink indirection.
+  // This ensures frontmatter (descriptions) is parsed correctly by Cursor for all components.
   const cursorOut = {
     ...cursorManifest,
-    commands: "./.cursor/commands",
-    agents: "./.cursor/agents",
+    commands: `${pathsBase}/commands`,
+    agents: `${pathsBase}/agents`,
     skills: `${pathsBase}/skills`,
   };
   // Claude Code only accepts name, description, author in plugin.json.
@@ -428,261 +426,151 @@ function writePluginManifests(targetRoot, dryRun, isSelfInstall) {
   console.log("Wrote: .cursor-plugin/plugin.json, .claude-plugin/plugin.json, .cursor-plugin/registration.json" + (isSelfInstall ? "" : ", .claude-plugin/marketplace.json"));
 }
 
+
+
+function copyDirRecursive(srcDir, destDir) {
+  fs.mkdirSync(destDir, { recursive: true });
+  for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
 /**
- * Cursor discovers skills only from .agents/skills, .cursor/skills, ~/.cursor/skills.
- * Populate .cursor/skills/ with symlinks to the package skills so Cursor finds them.
+ * Cursor discovers skills from .cursor/skills/ (each subdir with SKILL.md).
+ * Copy package skills so Cursor finds them with full frontmatter metadata.
  */
-function syncCursorSkills(targetRoot, dryRun, isSelfInstall) {
-  const packageSkillsAbs = isSelfInstall
-    ? path.join(PACKAGE_ROOT, "src", ".agents", "skills")
-    : path.join(targetRoot, "node_modules", "compound-workflow", "src", ".agents", "skills");
+function copyCursorSkills(targetRoot, dryRun, isSelfInstall) {
+  const packageSkillsAbs = path.join(
+    isSelfInstall ? PACKAGE_ROOT : path.join(targetRoot, "node_modules", "compound-workflow"),
+    "src", ".agents", "skills"
+  );
   if (!fs.existsSync(packageSkillsAbs)) return;
 
   const cursorSkillsDir = path.join(targetRoot, ".cursor", "skills");
-  let entries;
-  try {
-    entries = fs.readdirSync(packageSkillsAbs, { withFileTypes: true });
-  } catch {
-    return;
-  }
-
-  const skillDirs = entries.filter((e) => e.isDirectory() && fs.existsSync(path.join(packageSkillsAbs, e.name, "SKILL.md"))).map((e) => e.name);
+  const skillDirs = fs.readdirSync(packageSkillsAbs, { withFileTypes: true })
+    .filter((e) => e.isDirectory() && fs.existsSync(path.join(packageSkillsAbs, e.name, "SKILL.md")))
+    .map((e) => e.name);
   if (skillDirs.length === 0) return;
 
   if (dryRun) {
-    console.log("[dry-run] Would symlink", skillDirs.length, "skills into .cursor/skills/");
+    console.log("[dry-run] Would copy", skillDirs.length, "skills into .cursor/skills/");
     return;
   }
 
   fs.mkdirSync(cursorSkillsDir, { recursive: true });
-  const packageSkillsReal = realpathSafe(packageSkillsAbs);
   const skillSet = new Set(skillDirs);
 
-  // Prune: remove symlinks that point at our package but are no longer in the package
+  // Prune stale entries that we manage (contain SKILL.md) but are no longer in the package
   try {
     for (const entry of fs.readdirSync(cursorSkillsDir, { withFileTypes: true })) {
-      if (!entry.isSymbolicLink()) continue;
-      const linkPath = path.join(cursorSkillsDir, entry.name);
-      try {
-        const resolved = realpathSafe(linkPath);
-        if (!resolved.startsWith(packageSkillsReal + path.sep) && resolved !== packageSkillsReal) continue;
-        const base = path.basename(resolved);
-        if (skillSet.has(base)) continue;
-        fs.rmSync(linkPath);
-      } catch {
-        /* ignore broken symlinks or permission errors */
+      if (!entry.isDirectory()) continue;
+      const skillMd = path.join(cursorSkillsDir, entry.name, "SKILL.md");
+      if (!fs.existsSync(skillMd)) continue;
+      if (!skillSet.has(entry.name)) {
+        fs.rmSync(path.join(cursorSkillsDir, entry.name), { recursive: true, force: true });
       }
     }
-  } catch {
-    /* .cursor/skills not readable */
-  }
+  } catch { /* ignore */ }
 
   for (const name of skillDirs) {
-    const linkPath = path.join(cursorSkillsDir, name);
-    const targetPath = path.join(packageSkillsAbs, name);
-    try {
-      if (fs.existsSync(linkPath)) {
-        const stat = fs.lstatSync(linkPath);
-        if (!stat.isSymbolicLink()) continue;
-        try {
-          if (realpathSafe(linkPath) !== realpathSafe(targetPath)) continue;
-        } catch {
-          continue;
-        }
-        fs.rmSync(linkPath);
-      }
-      fs.symlinkSync(targetPath, linkPath, "dir");
-    } catch (err) {
-      if (err.code === "EPERM" && process.platform === "win32") {
-        try {
-          fs.symlinkSync(targetPath, linkPath, "junction");
-        } catch {
-          console.warn("[cursor] Could not symlink skill", name, err.message);
-        }
-      } else {
-        console.warn("[cursor] Could not symlink skill", name, err.message);
-      }
-    }
+    const dest = path.join(cursorSkillsDir, name);
+    fs.rmSync(dest, { recursive: true, force: true });
+    copyDirRecursive(path.join(packageSkillsAbs, name), dest);
   }
-  console.log("Synced", skillDirs.length, "skills to .cursor/skills/");
+  console.log("Copied", skillDirs.length, "skills to .cursor/skills/");
 }
 
 /**
- * Cursor discovers commands from .cursor/commands.
- * Populate .cursor/commands/ with symlinks to the package commands so Cursor finds them.
+ * Cursor discovers commands from .cursor/commands/ (.md files).
+ * Copy package commands so Cursor finds them with full frontmatter metadata.
  */
-function syncCursorCommands(targetRoot, dryRun, isSelfInstall) {
-  const packageCommandsAbs = isSelfInstall
-    ? path.join(PACKAGE_ROOT, "src", ".agents", "commands")
-    : path.join(targetRoot, "node_modules", "compound-workflow", "src", ".agents", "commands");
+function copyCursorCommands(targetRoot, dryRun, isSelfInstall) {
+  const packageCommandsAbs = path.join(
+    isSelfInstall ? PACKAGE_ROOT : path.join(targetRoot, "node_modules", "compound-workflow"),
+    "src", ".agents", "commands"
+  );
   if (!fs.existsSync(packageCommandsAbs)) return;
 
   const cursorCommandsDir = path.join(targetRoot, ".cursor", "commands");
-  let entries;
-  try {
-    entries = fs.readdirSync(packageCommandsAbs, { withFileTypes: true });
-  } catch {
-    return;
-  }
-
-  // Filter .md files that are commands
-  const commandFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".md")).map((e) => e.name);
+  const commandFiles = fs.readdirSync(packageCommandsAbs, { withFileTypes: true })
+    .filter((e) => e.isFile() && e.name.endsWith(".md"))
+    .map((e) => e.name);
   if (commandFiles.length === 0) return;
 
   if (dryRun) {
-    console.log("[dry-run] Would symlink", commandFiles.length, "commands into .cursor/commands/");
+    console.log("[dry-run] Would copy", commandFiles.length, "commands into .cursor/commands/");
     return;
   }
 
   fs.mkdirSync(cursorCommandsDir, { recursive: true });
-  const packageCommandsReal = realpathSafe(packageCommandsAbs);
   const commandSet = new Set(commandFiles);
 
-  // Prune: remove symlinks that point at our package but are no longer in the package
+  // Prune stale .md files and old symlinks that we previously managed
   try {
     for (const entry of fs.readdirSync(cursorCommandsDir, { withFileTypes: true })) {
-      if (!entry.isSymbolicLink()) continue;
-      const linkPath = path.join(cursorCommandsDir, entry.name);
-      try {
-        const resolved = realpathSafe(linkPath);
-        if (!resolved.startsWith(packageCommandsReal + path.sep) && resolved !== packageCommandsReal) continue;
-        const base = path.basename(resolved);
-        if (commandSet.has(base)) continue;
-        fs.rmSync(linkPath);
-      } catch {
-        /* ignore broken symlinks or permission errors */
+      if (!entry.name.endsWith(".md")) continue;
+      if (entry.isSymbolicLink() || !commandSet.has(entry.name)) {
+        fs.rmSync(path.join(cursorCommandsDir, entry.name), { force: true });
       }
     }
-  } catch {
-    /* .cursor/commands not readable */
-  }
+  } catch { /* ignore */ }
 
   for (const name of commandFiles) {
-    const linkPath = path.join(cursorCommandsDir, name);
-    const targetPath = path.join(packageCommandsAbs, name);
-    try {
-      if (fs.existsSync(linkPath)) {
-        const stat = fs.lstatSync(linkPath);
-        if (!stat.isSymbolicLink()) continue;
-        try {
-          if (realpathSafe(linkPath) !== realpathSafe(targetPath)) continue;
-        } catch {
-          continue;
-        }
-        fs.rmSync(linkPath);
-      }
-      fs.symlinkSync(targetPath, linkPath, "file");
-    } catch (err) {
-      console.warn("[cursor] Could not symlink command", name, err.message);
-    }
+    fs.copyFileSync(path.join(packageCommandsAbs, name), path.join(cursorCommandsDir, name));
   }
-  console.log("Synced", commandFiles.length, "commands to .cursor/commands/");
+  console.log("Copied", commandFiles.length, "commands to .cursor/commands/");
 }
 
 /**
- * Cursor discovers agents from .cursor/agents.
- * Populate .cursor/agents/ with symlinks to the package agents so Cursor finds them.
- * Preserves subdirectory structure (research/, workflow/, review/).
+ * Cursor discovers agents from .cursor/agents/ (.md files, supports subdirs).
+ * Copy package agents preserving subdirectory structure (research/, review/, workflow/).
  */
-function syncCursorAgents(targetRoot, dryRun, isSelfInstall) {
-  const packageAgentsAbs = isSelfInstall
-    ? path.join(PACKAGE_ROOT, "src", ".agents", "agents")
-    : path.join(targetRoot, "node_modules", "compound-workflow", "src", ".agents", "agents");
+function copyCursorAgents(targetRoot, dryRun, isSelfInstall) {
+  const packageAgentsAbs = path.join(
+    isSelfInstall ? PACKAGE_ROOT : path.join(targetRoot, "node_modules", "compound-workflow"),
+    "src", ".agents", "agents"
+  );
   if (!fs.existsSync(packageAgentsAbs)) return;
 
   const cursorAgentsDir = path.join(targetRoot, ".cursor", "agents");
-
-  // Get all agent files from manifest (these include subdir paths like "research/repo-research-analyst.md")
   const agentRels = GENERATED_MANIFEST.agents.map((a) => a.rel);
   if (agentRels.length === 0) return;
 
   if (dryRun) {
-    console.log("[dry-run] Would symlink", agentRels.length, "agents into .cursor/agents/");
+    console.log("[dry-run] Would copy", agentRels.length, "agents into .cursor/agents/");
     return;
   }
 
   fs.mkdirSync(cursorAgentsDir, { recursive: true });
-  const packageAgentsReal = realpathSafe(packageAgentsAbs);
-  const agentSet = new Set(agentRels);
 
-  // Build set of valid subdirectories to preserve structure
+  // Collect valid subdirectories from manifest
   const validSubdirs = new Set();
   for (const rel of agentRels) {
     const subdir = path.dirname(rel);
     if (subdir !== ".") validSubdirs.add(subdir);
   }
 
-  // Prune: remove symlinks that point at our package but are no longer in the manifest
+  // Prune stale subdirs and files
   try {
     for (const entry of fs.readdirSync(cursorAgentsDir, { withFileTypes: true })) {
-      if (entry.isDirectory()) {
-        // Check if this subdir is still valid
-        if (!validSubdirs.has(entry.name)) {
-          // Remove the entire stale subdirectory
-          fs.rmSync(path.join(cursorAgentsDir, entry.name), { recursive: true, force: true });
-          continue;
-        }
-        // Prune stale symlinks within valid subdirectories
-        const subdirPath = path.join(cursorAgentsDir, entry.name);
-        for (const subEntry of fs.readdirSync(subdirPath, { withFileTypes: true })) {
-          if (!subEntry.isSymbolicLink()) continue;
-          const linkPath = path.join(subdirPath, subEntry.name);
-          try {
-            const resolved = realpathSafe(linkPath);
-            if (!resolved.startsWith(packageAgentsReal + path.sep) && resolved !== packageAgentsReal) continue;
-            const relFromPackage = path.relative(packageAgentsAbs, resolved);
-            if (agentSet.has(relFromPackage)) continue;
-            fs.rmSync(linkPath);
-          } catch {
-            /* ignore broken symlinks */
-          }
-        }
-      } else if (entry.isSymbolicLink()) {
-        // Handle flat symlinks (if any were created at root level)
-        const linkPath = path.join(cursorAgentsDir, entry.name);
-        try {
-          const resolved = realpathSafe(linkPath);
-          if (!resolved.startsWith(packageAgentsReal + path.sep) && resolved !== packageAgentsReal) continue;
-          const relFromPackage = path.relative(packageAgentsAbs, resolved);
-          if (agentSet.has(relFromPackage)) continue;
-          fs.rmSync(linkPath);
-        } catch {
-          /* ignore broken symlinks */
-        }
+      if (entry.isDirectory() && !validSubdirs.has(entry.name)) {
+        fs.rmSync(path.join(cursorAgentsDir, entry.name), { recursive: true, force: true });
       }
     }
-  } catch {
-    /* .cursor/agents not readable */
-  }
+  } catch { /* ignore */ }
 
-  // Create symlinks preserving subdirectory structure
   for (const rel of agentRels) {
-    const targetPath = path.join(packageAgentsAbs, rel);
-    const linkPath = path.join(cursorAgentsDir, rel);
-
-    // Ensure subdirectory exists
-    const subdir = path.dirname(rel);
-    if (subdir !== ".") {
-      fs.mkdirSync(path.join(cursorAgentsDir, subdir), { recursive: true });
-    }
-
-    try {
-      if (fs.existsSync(linkPath)) {
-        const stat = fs.lstatSync(linkPath);
-        if (!stat.isSymbolicLink()) continue;
-        try {
-          if (realpathSafe(linkPath) !== realpathSafe(targetPath)) continue;
-        } catch {
-          continue;
-        }
-        fs.rmSync(linkPath);
-      }
-      fs.symlinkSync(targetPath, linkPath, "file");
-    } catch (err) {
-      console.warn("[cursor] Could not symlink agent", rel, err.message);
-    }
+    const destPath = path.join(cursorAgentsDir, rel);
+    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+    fs.copyFileSync(path.join(packageAgentsAbs, rel), destPath);
   }
-  console.log("Synced", agentRels.length, "agents to .cursor/agents/");
+  console.log("Copied", agentRels.length, "agents to .cursor/agents/");
 }
 
 function cursorDetected() {
@@ -690,149 +578,18 @@ function cursorDetected() {
 }
 
 /**
- * Verifies plugin integrity by checking all symlinks in .cursor/ directories
- * match the expected state from GENERATED_MANIFEST.
- * Returns { ok: boolean, issues: string[] }
+ * Register compound-workflow with Claude Code (project-scoped only).
+ * Cursor discovery is handled separately via copyCursor* functions.
  */
-function verifyPluginIntegrity(targetRoot, isSelfInstall) {
-  const issues = [];
-  const packageRoot = isSelfInstall
-    ? PACKAGE_ROOT
-    : path.join(targetRoot, "node_modules", "compound-workflow");
-
-  // Verify skills
-  const cursorSkillsDir = path.join(targetRoot, ".cursor", "skills");
-  const packageSkillsDir = path.join(packageRoot, "src", ".agents", "skills");
-  if (fs.existsSync(packageSkillsDir)) {
-    const expectedSkills = new Set(
-      fs.readdirSync(packageSkillsDir, { withFileTypes: true })
-        .filter((e) => e.isDirectory() && fs.existsSync(path.join(packageSkillsDir, e.name, "SKILL.md")))
-        .map((e) => e.name)
-    );
-    if (fs.existsSync(cursorSkillsDir)) {
-      const actualSkills = fs.readdirSync(cursorSkillsDir, { withFileTypes: true })
-        .filter((e) => e.isSymbolicLink())
-        .map((e) => e.name);
-      for (const skill of expectedSkills) {
-        if (!actualSkills.includes(skill)) {
-          issues.push(`Missing skill symlink: .cursor/skills/${skill}`);
-        }
-      }
-      for (const skill of actualSkills) {
-        if (!expectedSkills.has(skill)) {
-          issues.push(`Stale skill symlink: .cursor/skills/${skill}`);
-        }
-      }
-    } else if (expectedSkills.size > 0) {
-      issues.push(`Missing .cursor/skills/ directory (${expectedSkills.size} expected)`);
-    }
-  }
-
-  // Verify commands
-  const cursorCommandsDir = path.join(targetRoot, ".cursor", "commands");
-  const packageCommandsDir = path.join(packageRoot, "src", ".agents", "commands");
-  if (fs.existsSync(packageCommandsDir)) {
-    const expectedCommands = new Set(
-      fs.readdirSync(packageCommandsDir, { withFileTypes: true })
-        .filter((e) => e.isFile() && e.name.endsWith(".md"))
-        .map((e) => e.name)
-    );
-    if (fs.existsSync(cursorCommandsDir)) {
-      const actualCommands = fs.readdirSync(cursorCommandsDir, { withFileTypes: true })
-        .filter((e) => e.isSymbolicLink())
-        .map((e) => e.name);
-      for (const cmd of expectedCommands) {
-        if (!actualCommands.includes(cmd)) {
-          issues.push(`Missing command symlink: .cursor/commands/${cmd}`);
-        }
-      }
-      for (const cmd of actualCommands) {
-        if (!expectedCommands.has(cmd)) {
-          issues.push(`Stale command symlink: .cursor/commands/${cmd}`);
-        }
-      }
-    } else if (expectedCommands.size > 0) {
-      issues.push(`Missing .cursor/commands/ directory (${expectedCommands.size} expected)`);
-    }
-  }
-
-  // Verify agents
-  const cursorAgentsDir = path.join(targetRoot, ".cursor", "agents");
-  const packageAgentsDir = path.join(packageRoot, "src", ".agents", "agents");
-  if (fs.existsSync(packageAgentsDir)) {
-    // Recursively get all .md files from package agents dir
-    const expectedAgents = [];
-    function collectAgents(dir, prefix = "") {
-      for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-          collectAgents(path.join(dir, entry.name), relPath);
-        } else if (entry.isFile() && entry.name.endsWith(".md")) {
-          expectedAgents.push(relPath);
-        }
-      }
-    }
-    collectAgents(packageAgentsDir);
-    const expectedSet = new Set(expectedAgents);
-
-    if (fs.existsSync(cursorAgentsDir)) {
-      const actualAgents = [];
-      function collectActualAgents(dir, prefix = "") {
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-          const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            collectActualAgents(path.join(dir, entry.name), relPath);
-          } else if (entry.isSymbolicLink()) {
-            actualAgents.push(relPath);
-          }
-        }
-      }
-      collectActualAgents(cursorAgentsDir);
-      const actualSet = new Set(actualAgents);
-
-      for (const agent of expectedAgents) {
-        if (!actualSet.has(agent)) {
-          issues.push(`Missing agent symlink: .cursor/agents/${agent}`);
-        }
-      }
-      for (const agent of actualAgents) {
-        if (!expectedSet.has(agent)) {
-          issues.push(`Stale agent symlink: .cursor/agents/${agent}`);
-        }
-      }
-    } else if (expectedAgents.length > 0) {
-      issues.push(`Missing .cursor/agents/ directory (${expectedAgents.length} expected)`);
-    }
-  }
-
-  return { ok: issues.length === 0, issues };
-}
-
-function applyCursorRegistration(targetRoot, dryRun, noRegisterCursor, forceRegister, isSelfInstall) {
-  const claudePluginsDir = path.join(os.homedir(), ".claude", "plugins");
-  const installedPath = path.join(claudePluginsDir, "installed_plugins.json");
-  const settingsPath = path.join(os.homedir(), ".claude", "settings.json");
-
-  const pluginVersion = (() => {
-    try {
-      const pkgPath = path.join(PACKAGE_ROOT, "package.json");
-      return JSON.parse(fs.readFileSync(pkgPath, "utf8")).version || "0.0.0";
-    } catch {
-      return "0.0.0";
-    }
-  })();
-
+function applyClaudeRegistration(targetRoot, dryRun, isSelfInstall) {
   const projectRoot = isSelfInstall ? PACKAGE_ROOT : targetRoot;
-  const pluginId = "compound-workflow@local";
+  const pluginId = "compound-workflow@compound-workflow-local";
 
   if (dryRun) {
     console.log("[dry-run] Would register Claude plugin (project-scoped) at:", projectRoot);
     return;
   }
 
-  // Registration is always project-scoped: write only to <project>/.claude/settings.json.
-  // Claude Code manages ~/.claude/plugins/installed_plugins.json itself via marketplace flow;
-  // writing to user-level files causes "unregistered local marketplace" errors on startup.
   const projectSettingsPath = path.join(projectRoot, ".claude", "settings.json");
   let projectSettings = {};
   if (fs.existsSync(projectSettingsPath)) {
@@ -840,52 +597,21 @@ function applyCursorRegistration(targetRoot, dryRun, noRegisterCursor, forceRegi
   }
   projectSettings.enabledPlugins = ensureObject(projectSettings.enabledPlugins);
   projectSettings.enabledPlugins[pluginId] = true;
-  // Remove stale/invalid marketplace keys left by earlier install methods
   if (projectSettings.extraKnownMarketplaces?.["compound-workflow"]) {
     delete projectSettings.extraKnownMarketplaces["compound-workflow"];
   }
   projectSettings.extraKnownMarketplaces = ensureObject(projectSettings.extraKnownMarketplaces);
   projectSettings.extraKnownMarketplaces["compound-workflow-local"] = {
-    source: { source: "file", path: ".claude-plugin/marketplace.json" },
+    source: { source: "file", path: "." },
   };
   fs.mkdirSync(path.join(projectRoot, ".claude"), { recursive: true });
   fs.writeFileSync(projectSettingsPath, JSON.stringify(projectSettings, null, 2) + "\n", "utf8");
 
-  // Clean up any stale user-level enabledPlugins entries left by previous install versions.
-  // These cause "unregistered local marketplace" errors on every Claude Code startup.
-  if (fs.existsSync(settingsPath)) {
-    try {
-      let userSettings = readJsonMaybe(settingsPath) ?? {};
-      const staleIds = ["compound-workflow@local", "compound-workflow@compound-workflow-local"];
-      let changed = false;
-      for (const id of staleIds) {
-        if (userSettings?.enabledPlugins?.[id] !== undefined) {
-          delete userSettings.enabledPlugins[id];
-          changed = true;
-        }
-      }
-      if (changed) {
-        fs.writeFileSync(settingsPath, JSON.stringify(userSettings, null, 2) + "\n", "utf8");
-        console.log("Cleaned up stale compound-workflow entries from ~/.claude/settings.json");
-      }
-    } catch { /* ignore */ }
-  }
-
   console.log("Registered compound-workflow with Claude Code (project-scoped).");
   if (!isSelfInstall) {
     console.log("  Claude Code 2.1+: open /plugin, go to Discover; install 'compound-workflow' from marketplace 'compound-workflow-local', or run: claude --plugin-dir ./node_modules/compound-workflow");
   }
   console.log("  Restart Claude Code; enable 'Include third-party Plugins, Skills, and other configs' in Settings if needed.");
-
-  if (noRegisterCursor && !forceRegister) return;
-  const shouldApply = forceRegister || (cursorDetected() && !noRegisterCursor);
-  if (!shouldApply) {
-    console.log("[cursor] Cursor not detected; skipped Cursor plugin registration. Use --register-cursor to force.");
-    return;
-  }
-  const registrationPath = path.join(targetRoot, ".cursor-plugin", "registration.json");
-  if (!fs.existsSync(registrationPath)) return;
-  console.log("Registered compound-workflow with Cursor. Restart Cursor; enable 'Include third-party Plugins, Skills, and other configs' in Settings if needed.");
 }
 
 function reportOpenCodeIntegration(targetRoot, dryRun) {
@@ -910,31 +636,6 @@ function main() {
   const args = parseArgs(process.argv);
   const targetRoot = realpathSafe(args.root);
 
-  // Handle verification mode early (no manifest needed)
-  if (args.verify) {
-    console.log("Verifying plugin integrity...");
-    const isSelfInstall = realpathSafe(targetRoot) === realpathSafe(PACKAGE_ROOT);
-    // Try to read manifest for accurate verification, but continue without it
-    try {
-      GENERATED_MANIFEST = readGeneratedManifest();
-    } catch {
-      console.warn("Warning: Could not read generated manifest, using filesystem scan only");
-      GENERATED_MANIFEST = { commands: [], agents: [] };
-    }
-    const result = verifyPluginIntegrity(targetRoot, isSelfInstall);
-    if (result.ok) {
-      console.log("Plugin integrity: OK (all symlinks present and valid)");
-      process.exit(0);
-    } else {
-      console.error("Plugin integrity issues found:");
-      for (const issue of result.issues) {
-        console.error(`  - ${issue}`);
-      }
-      console.error("\nRun 'npx compound-workflow install' to fix.");
-      process.exit(1);
-    }
-  }
-
   const genScript = path.join(PACKAGE_ROOT, "scripts", "generate-platform-artifacts.mjs");
   if (fs.existsSync(genScript)) {
     console.log("[compound-workflow] Regenerating manifest from package source...");
@@ -977,10 +678,10 @@ function main() {
 
   writeOpenCodeJson(targetRoot, args.dryRun, isSelfInstall);
   writePluginManifests(targetRoot, args.dryRun, isSelfInstall);
-  syncCursorSkills(targetRoot, args.dryRun, isSelfInstall);
-  syncCursorCommands(targetRoot, args.dryRun, isSelfInstall);
-  syncCursorAgents(targetRoot, args.dryRun, isSelfInstall);
-  applyCursorRegistration(targetRoot, args.dryRun, args.noRegisterCursor, args.registerCursor, isSelfInstall);
+  applyClaudeRegistration(targetRoot, args.dryRun, isSelfInstall);
+  copyCursorSkills(targetRoot, args.dryRun, isSelfInstall);
+  copyCursorCommands(targetRoot, args.dryRun, isSelfInstall);
+  copyCursorAgents(targetRoot, args.dryRun, isSelfInstall);
   reportOpenCodeIntegration(targetRoot, args.dryRun);
   writeAgentsMd(targetRoot, args.dryRun);
   ensureDirs(targetRoot, args.dryRun);