set-prompt 0.3.0 → 0.5.2

package/dist/index.js

@@ -2,23 +2,25 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk8 from "chalk";
+import chalk15 from "chalk";
 import figlet from "figlet";
-import fs6 from "fs";
-import path5 from "path";
+import fs11 from "fs";
+import path10 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/install-command.ts
 import fs3 from "fs";
 import path3 from "path";
 import { spawnSync } from "child_process";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { confirm as confirm2 } from "@inquirer/prompts";
 
 // src/_defs/index.ts
 import path from "path";
 import os from "os";
 var TAB = `    `;
+var MARKET_NAME = "set-prompt";
+var PLUGIN_NAME = "sppt";
 var HOME_DIR = path.join(os.homedir(), ".set-prompt");
 var CONFIG_PATH = path.join(HOME_DIR, "config.json");
 var REPO_DIR = path.join(HOME_DIR, "repo");
@@ -29,20 +31,25 @@ var OPENCLAW_DIR = path.join(os.homedir(), ".openclaw", "workspace");
 var OPENCLAW_BACKUP_DIR = path.join(OPENCLAW_DIR, "SET_PROMPT_BACKUP");
 var ANTIGRAVITY_DIR = path.join(os.homedir(), ".gemini", "antigravity");
 var ANTIGRAVITY_BACKUP_DIR = path.join(ANTIGRAVITY_DIR, "SET_PROMPT_BACKUP");
-var PROMPT_DIR_NAMES = ["skills", "commands", "hooks", "agents"];
+var CODEX_DIR = path.join(HOME_DIR, "codex");
+var CODEX_BACKUP_DIR = path.join(CODEX_DIR, "SET_PROMPT_BACKUP");
+var CURSOR_DIR = path.join(os.homedir(), ".cursor");
+var PROMPT_DIR_NAMES = ["skills", "commands", "hooks", "agents", "rules"];
 var AGENT_PROMPT_DIRS = {
   ["claudecode" /* CLAUDECODE */]: ["skills", "commands", "hooks", "agents"],
   ["roocode" /* ROOCODE */]: ["skills", "commands"],
   ["openclaw" /* OPENCLAW */]: ["skills"],
-  ["codex" /* CODEX */]: ["skills", "commands"],
-  ["antigravity" /* ANTIGRAVITY */]: ["skills"]
+  ["codex" /* CODEX */]: ["skills"],
+  ["antigravity" /* ANTIGRAVITY */]: ["skills"],
+  ["cursor" /* CURSOR */]: ["skills", "agents", "commands", "hooks"]
 };
 var ALL_AGENTS = [
   { name: "Claude Code", value: "claudecode" /* CLAUDECODE */ },
   { name: "RooCode", value: "roocode" /* ROOCODE */ },
   { name: "OpenClaw", value: "openclaw" /* OPENCLAW */ },
   { name: "Codex", value: "codex" /* CODEX */ },
-  { name: "Antigravity", value: "antigravity" /* ANTIGRAVITY */ }
+  { name: "Antigravity", value: "antigravity" /* ANTIGRAVITY */ },
+  { name: "Cursor", value: "cursor" /* CURSOR */ }
 ];
 
 // src/_libs/config.ts
@@ -65,12 +72,17 @@ var OpenclawConfigSchema = z.object({
   backup_path: z.string().nullish().optional()
 });
 var CodexConfigSchema = z.object({
-  path: z.string().nullable()
+  path: z.string().nullable(),
+  backup_path: z.string().nullish().optional()
 });
 var AntigravityConfigSchema = z.object({
   path: z.string().nullable(),
   backup_path: z.string().nullish().optional()
 });
+var CursorConfigSchema = z.object({
+  path: z.string().nullable(),
+  backup_path: z.string().nullish().optional()
+});
 var GlobalConfigSchema = z.object({
   repo_path: z.string(),
   remote_url: z.string().nullable(),
@@ -78,7 +90,8 @@ var GlobalConfigSchema = z.object({
   roocode: RoocodeConfigSchema.nullable(),
   openclaw: OpenclawConfigSchema.nullable(),
   codex: CodexConfigSchema.nullish().optional(),
-  antigravity: AntigravityConfigSchema.nullish().optional()
+  antigravity: AntigravityConfigSchema.nullish().optional(),
+  cursor: CursorConfigSchema.nullish().optional()
 });
 
 // src/_libs/config.ts
@@ -91,6 +104,7 @@ var ConfigManager = class {
     this._openclaw = null;
     this._codex = null;
     this._antigravity = null;
+    this._cursor = null;
   }
   get repo_path() {
     return this._repo_path;
@@ -113,6 +127,9 @@ var ConfigManager = class {
   get antigravity() {
     return this._antigravity;
   }
+  get cursor() {
+    return this._cursor;
+  }
   set repo_path(v) {
     this._repo_path = v;
   }
@@ -134,10 +151,13 @@ var ConfigManager = class {
   set antigravity(v) {
     this._antigravity = v;
   }
+  set cursor(v) {
+    this._cursor = v;
+  }
   init() {
     this._loadFromDisk();
     if (this._repo_path != null) {
-      console.log(chalk.dim(`Config loaded from ${CONFIG_PATH}`));
+      console.log(chalk.green(`Config loaded`) + chalk.dim(` from ${CONFIG_PATH}`));
     }
   }
   save() {
@@ -154,7 +174,8 @@ var ConfigManager = class {
         roocode: this._roocode,
         openclaw: this._openclaw,
         codex: this._codex,
-        antigravity: this._antigravity
+        antigravity: this._antigravity,
+        cursor: this._cursor
       }, null, 4);
       fs.writeFileSync(CONFIG_PATH, configStr, "utf-8");
       console.log(chalk.green(`Config saved`) + chalk.dim(` \u2192 ${CONFIG_PATH}`));
@@ -188,6 +209,9 @@ var ConfigManager = class {
   isAntigravityEnabled() {
     return this._antigravity != null;
   }
+  isCursorEnabled() {
+    return this._cursor != null;
+  }
   _assign(config) {
     this._repo_path = config.repo_path;
     this._remote_url = config.remote_url;
@@ -196,6 +220,7 @@ var ConfigManager = class {
     this._openclaw = config.openclaw;
     this._codex = config.codex ?? null;
     this._antigravity = config.antigravity ?? null;
+    this._cursor = config.cursor ?? null;
   }
   _loadFromDisk() {
     if (fs.existsSync(CONFIG_PATH) === false) {
@@ -214,23 +239,33 @@ var ConfigManager = class {
 var configManager = new ConfigManager();
 
 // src/_libs/index.ts
+import chalk2 from "chalk";
 var isGitUrl = (source) => source.startsWith("http://") || source.startsWith("https://") || source.startsWith("git@") || source.startsWith("ssh://") || source.endsWith(".git") && (source.startsWith("http") || source.startsWith("git@") || source.startsWith("ssh://"));
+var resolveRepoPath = () => {
+  if (configManager.repo_path == null) {
+    console.error(chalk2.red("\u274C No repo installed."));
+    console.log(chalk2.yellow("Run: set-prompt install <git-url>"));
+    return null;
+  }
+  return configManager.repo_path;
+};
 
 // src/commands/scaffold-command.ts
 import fs2 from "fs";
 import path2 from "path";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 import { confirm } from "@inquirer/prompts";
 
 // src/_libs/templates.ts
 var SET_PROMPT_GUIDE = `# Set Prompt Repository Guide
 
-> Managed by [set-prompt](https://github.com/alkemic-studio/set-prompt)
+> Managed by [set-prompt](https://github.com/juncha9/set-prompt)
+
+This is a shared prompt repository linked to various AI agents via \`set-prompt link\`. When writing or editing prompts in this repository, refer to the structure below and the frontmatter reference for each platform's conventions.
 
 ## Structure
 
 \`\`\`
-\u251C\u2500\u2500 set-prompt.toml        # Repository configuration
 \u251C\u2500\u2500 skills/
 \u2502   \u2514\u2500\u2500 <skill-name>/
 \u2502       \u251C\u2500\u2500 SKILL.md       # Platform-specific frontmatter + prompt content
@@ -239,10 +274,27 @@ var SET_PROMPT_GUIDE = `# Set Prompt Repository Guide
 \u2502   \u2514\u2500\u2500 <command-name>/
 \u2502       \u251C\u2500\u2500 COMMAND.md     # Platform-specific frontmatter + prompt content
 \u2502       \u2514\u2500\u2500 ...            # Supporting files
-\u251C\u2500\u2500 hooks/                 # Lifecycle shell hooks
-\u2514\u2500\u2500 agents/                # Agent definitions (Claude Code)
-    \u2514\u2500\u2500 <agent-name>/
-        \u2514\u2500\u2500 AGENT.md
+\u251C\u2500\u2500 hooks/                 # Lifecycle shell hooks (Claude Code)
+\u251C\u2500\u2500 agents/                # Agent definitions (Claude Code, Cursor)
+\u2502   \u2514\u2500\u2500 <agent-name>/
+\u2502       \u2514\u2500\u2500 AGENT.md
+\u2514\u2500\u2500 rules/                 # Rule definitions (Cursor)
+    \u2514\u2500\u2500 <rule-name>/
+        \u2514\u2500\u2500 RULE.md
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+# Scaffold this repo's directory structure
+set-prompt scaffold .
+
+# Install from remote and link to AI tools
+set-prompt install https://github.com/you/my-prompts
+set-prompt link
+
+# Pull latest changes
+set-prompt update
 \`\`\`
 
 ## Frontmatter Reference
@@ -292,6 +344,15 @@ metadata: {"os":["darwin","linux"],"requires":{"bins":["git"],"env":["MY_API_KEY
 # Antigravity
 name: my-skill
 description: "What this skill does and when to use it"
+
+# Cursor
+name: "my-skill"
+description: "What this skill does and when to use it"
+license: "MIT"
+compatibility: "Requires Node.js 18+"
+metadata:
+  category: "development"
+disable-model-invocation: false
 ---
 \`\`\`
 
@@ -313,10 +374,13 @@ description: "What this skill does and when to use it"
 | \`metadata\` | No | OpenClaw | Single-line JSON for platform gating: \`os\` (platform filter), \`requires.bins\` (required binaries), \`requires.env\` (required env vars) |
 | \`homepage\` | No | OpenClaw | URL shown as "Website" in the macOS Skills UI. Also settable via \`metadata.openclaw.homepage\`. |
 | \`user-invocable\` | No | OpenClaw | \`false\` = hidden from \`/\` menu. (default: \`true\`) |
-| \`disable-model-invocation\` | No | CC, OpenClaw | \`true\` = skill excluded from model prompt, still available via user invocation. (default: \`false\`) |
+| \`disable-model-invocation\` | No | Claude Code, OpenClaw, Cursor | \`true\` = skill only included when explicitly invoked via \`/skill-name\`. (default: \`false\`) |
 | \`command-dispatch\` | No | OpenClaw | \`"tool"\` = bypass model, dispatch directly to a tool |
 | \`command-tool\` | No | OpenClaw | Tool to invoke when \`command-dispatch: "tool"\` |
 | \`command-arg-mode\` | No | OpenClaw | How arguments are forwarded to the tool. (default: \`"raw"\`) |
+| \`license\` | No | Cursor | License name or reference to a bundled license file. |
+| \`compatibility\` | No | Cursor | Environment requirements (system packages, network access, etc.) |
+| \`metadata\` | No | Cursor | Arbitrary key-value mapping for additional metadata. |
 
 ---
 
@@ -360,7 +424,7 @@ command-tool: "Bash"
 |-------|----------|----------|-------------|
 | \`name\` | No | All | Display name \u2014 lowercase, numbers, hyphens only (max 64 chars). Defaults to directory name. |
 | \`description\` | Yes | All | Shown in \`/\` menu. Claude uses this to decide auto-loading. |
-| \`user-invocable\` | No | CC, OpenClaw | \`false\` = hidden from \`/\` menu, background knowledge only. (default: \`true\`) |
+| \`user-invocable\` | No | Claude Code, OpenClaw | \`false\` = hidden from \`/\` menu, background knowledge only. (default: \`true\`) |
 | \`allowed-tools\` | No | Claude Code | Tools Claude can use without asking. e.g. \`Read\` \`Write\` \`Edit\` \`Bash\` \`Grep\` \`Glob\` |
 | \`argument-hint\` | No | Claude Code | Hint shown during autocomplete. e.g. \`[issue-number]\` |
 | \`model\` | No | Claude Code | Model to use when active. \`sonnet\` or \`haiku\` |
@@ -372,10 +436,11 @@ command-tool: "Bash"
 
 ### Agents
 
-Custom subagent definitions loaded by Claude Code.
+Custom subagent definitions loaded by Claude Code and Cursor.
 
 \`\`\`yaml
 ---
+# Claude Code
 name: "my-agent"
 description: "What this agent does and when to use it"
 allowed-tools:
@@ -383,37 +448,87 @@ allowed-tools:
   - Bash
 model: sonnet
 context: fork
+
+# Cursor
+name: "my-agent"
+description: "What this agent does and when to use it"
+model: inherit
+readonly: false
+is_background: false
+---
+\`\`\`
+
+| Field | Required | Platform | Description |
+|-------|----------|----------|-------------|
+| \`name\` | Yes | All | Display name. Claude Code: lowercase, numbers, hyphens only (max 64 chars). Cursor: defaults to folder name. |
+| \`description\` | Yes | All | When and how to use this agent. Used to decide when to spawn/delegate. |
+| \`allowed-tools\` | No | Claude Code | Tools this agent can use without asking |
+| \`model\` | No | All | Claude Code: \`sonnet\` or \`haiku\`. Cursor: \`fast\`, \`inherit\`, or a specific model ID. |
+| \`context\` | No | Claude Code | \`fork\` = run in isolated subagent context |
+| \`readonly\` | No | Cursor | \`true\` = sub-agent runs with restricted write permissions (no file edits or state-changing shell commands). (default: \`false\`) |
+| \`is_background\` | No | Cursor | \`true\` = sub-agent runs in background without blocking parent. (default: \`false\`) |
+
+---
+
+### Rules
+
+System-level instructions for the AI agent. Cursor only. Rules are markdown files (\`.md\` or \`.mdc\`) stored in \`.cursor/rules/\`. When a rule is active, its content is prepended to the model context.
+
+\`\`\`yaml
+---
+description: "When and how this rule should be applied"
+globs:
+  - "**/*.ts"
+  - "**/*.tsx"
+alwaysApply: false
 ---
+
+Use \`@filename\` to reference files instead of copying content.
 \`\`\`
 
+**Activation Types**
+
+| Type | \`alwaysApply\` | \`globs\` | \`description\` | Behavior |
+|------|:-----------:|:-----:|:-----------:|----------|
+| Always | \`true\` | ignored | optional | Included in every conversation |
+| Auto Attached | \`false\` | set | optional | Included when open files match glob patterns |
+| Agent Requested | \`false\` | empty | set | AI decides based on description relevance |
+| Manual | \`false\` | empty | empty | Invoked via \`@rule-name\` mention only |
+
 | Field | Required | Description |
 |-------|----------|-------------|
-| \`name\` | Yes | Display name \u2014 lowercase, numbers, hyphens only (max 64 chars) |
-| \`description\` | Yes | When and how to use this agent. Claude uses this to decide when to spawn it. |
-| \`allowed-tools\` | No | Tools this agent can use without asking |
-| \`model\` | No | Model override. \`sonnet\` or \`haiku\` |
-| \`context\` | No | \`fork\` = run in isolated subagent context |
+| \`description\` | No | Describes the rule's purpose. Used by AI to decide relevance (Agent Requested type). |
+| \`globs\` | No | File patterns for auto-attachment. e.g. \`["**/*.ts", "src/components/**"]\` |
+| \`alwaysApply\` | No | \`true\` = always included regardless of context. (default: \`false\`) |
+
+**Priority**: Team Rules > Project Rules (\`.cursor/rules/\`) > User Rules (Cursor Settings) > \`AGENTS.md\`
+
+**Best practices**: Keep rules under 500 lines. Reference files with \`@filename\` instead of copying. Be specific \u2014 avoid duplicating what linters or the agent already knows.
 
 ---
 
 ### Hooks
 
-Lifecycle shell commands (or LLM prompts) that fire at specific points. Hooks in skill/command frontmatter are scoped to that component \u2014 active while it runs, removed when it finishes.
+Lifecycle scripts that fire at specific points in the agent loop. Both Claude Code and Cursor support hooks, but with different configuration formats and event models.
+
+#### Claude Code Hooks
+
+Defined in YAML frontmatter within skill/command files. Scoped to that component \u2014 active while it runs, removed when it finishes.
 
 \`\`\`yaml
 hooks:
   PreToolUse:
-    - matcher: "Bash"          # regex matched against tool name
+    - matcher: "Bash"
       hooks:
         - type: command
           command: ".claude/hooks/validate.sh"
-          timeout: 30          # seconds (default: 600)
+          timeout: 30
   PostToolUse:
     - matcher: "Write|Edit"
       hooks:
         - type: command
           command: "npm run lint"
-          async: true          # run in background, non-blocking
+          async: true
   Stop:
     - hooks:
         - type: prompt
@@ -429,12 +544,10 @@ hooks:
 | \`PostToolUseFailure\` | tool name | No | After a tool fails |
 | \`UserPromptSubmit\` | \u2014 | Yes | When user submits a prompt |
 | \`SessionStart\` | \`startup\` \\| \`resume\` \\| \`clear\` \\| \`compact\` | No | Session begins |
-| \`Stop\` | \u2014 | Yes | Claude finishes responding |
+| \`Stop\` | \u2014 | Yes | Agent finishes responding |
 | \`Notification\` | \`permission_prompt\` \\| \`idle_prompt\` | No | Notification fires |
 | \`SubagentStart\` / \`SubagentStop\` | agent type | No / Yes | Subagent spawned / finished |
 
-Full event list: [hooks reference](https://code.claude.com/docs/en/hooks)
-
 **Handler fields**
 
 | Field | Type | Description |
@@ -443,57 +556,134 @@ Full event list: [hooks reference](https://code.claude.com/docs/en/hooks)
 | \`command\` | command only | Shell command to execute. Receives hook JSON on stdin |
 | \`prompt\` | prompt/agent | Prompt text. Use \`$ARGUMENTS\` for the hook JSON input |
 | \`timeout\` | all | Seconds before cancel. Defaults: 600 / 30 / 60 |
-| \`async\` | command only | \`true\` = run in background, cannot block Claude |
+| \`async\` | command only | \`true\` = run in background, cannot block |
 | \`once\` | command only | \`true\` = run once per session then remove (skills only) |
 
-**Decision control** (command hooks)
+Full event list: [Claude Code hooks reference](https://code.claude.com/docs/en/hooks)
 
-Exit \`0\` = allow. Exit \`2\` = block (stderr is fed to Claude as the reason). Print JSON to stdout for richer control:
+---
 
-\`\`\`bash
-# PreToolUse: deny via JSON
-echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"reason"}}'
+#### Cursor Hooks
+
+Defined in \`hooks.json\` \u2014 not in frontmatter. Project-level (\`.cursor/hooks.json\`) or user-level (\`~/.cursor/hooks.json\`). Supports both command-based and prompt-based (LLM evaluation) handlers.
 
-# Stop/PostToolUse: block via JSON
-echo '{"decision":"block","reason":"Tests must pass first"}'
+\`\`\`json
+{
+  "version": 1,
+  "hooks": {
+    "afterFileEdit": [{ "command": ".cursor/hooks/format.sh" }],
+    "beforeShellExecution": [
+      { "command": ".cursor/hooks/approve.sh", "matcher": "curl|wget", "timeout": 30 }
+    ],
+    "stop": [{ "command": ".cursor/hooks/audit.sh", "loop_limit": 10 }],
+    "beforeReadFile": [{ "command": ".cursor/hooks/redact.sh", "failClosed": true }],
+    "preToolUse": [
+      { "type": "prompt", "prompt": "Is this tool call safe?", "matcher": "Shell" }
+    ]
+  }
+}
 \`\`\`
 
-## Usage
+**Agent Events**
 
-\`\`\`bash
-# Scaffold this repo's directory structure
-set-prompt scaffold .
+| Event | Matcher | Can Block | When it fires |
+|-------|---------|:---------:|---------------|
+| \`sessionStart\` | \u2014 | No | New conversation created |
+| \`sessionEnd\` | \u2014 | No | Conversation ends |
+| \`preToolUse\` | tool type | Yes | Before any tool runs |
+| \`postToolUse\` | tool type | No | After a tool succeeds |
+| \`postToolUseFailure\` | tool type | No | After a tool fails/times out |
+| \`subagentStart\` | agent type | Yes | Before sub-agent spawns |
+| \`subagentStop\` | agent type | Yes\\* | Sub-agent completes (\\*followup_message) |
+| \`beforeShellExecution\` | command text | Yes | Before shell command runs |
+| \`afterShellExecution\` | \u2014 | No | After shell command completes |
+| \`beforeMCPExecution\` | \u2014 | Yes | Before MCP tool runs |
+| \`afterMCPExecution\` | \u2014 | No | After MCP tool completes |
+| \`beforeReadFile\` | tool type | Yes | Before file read |
+| \`afterFileEdit\` | tool type | No | After file is edited |
+| \`beforeSubmitPrompt\` | \u2014 | Yes | Before prompt sent to backend |
+| \`preCompact\` | \u2014 | No | Before context compaction (observe only) |
+| \`stop\` | \u2014 | Yes\\* | Agent loop ends (\\*followup_message) |
+| \`afterAgentResponse\` | \u2014 | No | After assistant message |
+| \`afterAgentThought\` | \u2014 | No | After thinking block |
 
-# Install from remote and link to AI tools
-set-prompt install https://github.com/you/my-prompts
-set-prompt link
+**Tab Events** (inline autocomplete only)
 
-# Pull latest changes
-set-prompt update
+| Event | When it fires |
+|-------|---------------|
+| \`beforeTabFileRead\` | Before Tab reads a file |
+| \`afterTabFileEdit\` | After Tab edits a file |
+
+**Handler fields**
+
+| Field | Type | Default | Description |
+|-------|------|---------|-------------|
+| \`command\` | string | required | Script path or shell command |
+| \`type\` | string | \`"command"\` | \`"command"\` or \`"prompt"\` (LLM evaluation) |
+| \`timeout\` | number | platform default | Execution timeout in seconds |
+| \`matcher\` | string | \u2014 | Regex filter for when the hook fires |
+| \`loop_limit\` | number\\|null | \`5\` | Max auto-followups for stop/subagentStop. \`null\` = unlimited |
+| \`failClosed\` | boolean | \`false\` | \`true\` = block on hook failure instead of fail-open |
+
+Full event list: [Cursor hooks reference](https://cursor.com/docs/hooks)
+
+---
+
+**Decision control** (both platforms)
+
+Exit \`0\` = allow. Exit \`2\` = block. Claude Code reads stderr as the reason. Cursor uses JSON stdout:
+
+\`\`\`bash
+# Claude Code: deny via JSON
+echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"reason"}}'
+
+# Cursor: deny via JSON
+echo '{"permission":"deny","user_message":"Blocked by policy","agent_message":"Not allowed"}'
 \`\`\`
+
 `;
 
 // src/commands/scaffold-command.ts
-var REQUIRED_DIRS = ["skills", "commands"];
-var OPTIONAL_DIRS = ["hooks", "agents"];
-var printStructure = async (localPath) => {
-  let valid = true;
-  for (const dir of REQUIRED_DIRS) {
-    const exists = fs2.existsSync(path2.join(localPath, dir));
-    if (exists) {
-      console.log(`${TAB}\u2705 ${dir}/`);
-    } else {
-      console.log(`${TAB}\u274C ${dir}/ ${chalk2.red("(missing)")}`);
-      valid = false;
-    }
+var ensureClaudePluginManifest = (repoPath) => {
+  const metaDir = path2.join(repoPath, ".claude-plugin");
+  const jsonPath = path2.join(metaDir, "plugin.json");
+  fs2.mkdirSync(metaDir, { recursive: true });
+  fs2.writeFileSync(jsonPath, JSON.stringify({
+    name: PLUGIN_NAME,
+    version: "1.0.0",
+    description: `Managed by set-prompt \u2014 ${repoPath}`
+  }, null, 4), { encoding: "utf-8" });
+};
+var ensureCodexPluginManifest = (repoPath) => {
+  const metaDir = path2.join(repoPath, ".codex-plugin");
+  const jsonPath = path2.join(metaDir, "plugin.json");
+  fs2.mkdirSync(metaDir, { recursive: true });
+  fs2.writeFileSync(jsonPath, JSON.stringify({
+    name: PLUGIN_NAME,
+    version: "1.0.0",
+    description: `Managed by set-prompt \u2014 ${repoPath}`,
+    skills: "./skills/",
+    mcpServers: "./mcp.json",
+    apps: "./.app.json"
+  }, null, 4), { encoding: "utf-8" });
+};
+var ensureMcpJson = (repoPath) => {
+  const mcpJsonPath = path2.join(repoPath, "mcp.json");
+  if (fs2.existsSync(mcpJsonPath)) {
+    return false;
   }
-  for (const dir of OPTIONAL_DIRS) {
-    const exists = fs2.existsSync(path2.join(localPath, dir));
-    console.log(`${TAB}${chalk2.dim(exists ? "\u2713" : "\u25CB")} ${dir}/ ${exists ? "" : chalk2.dim("(optional)")}`);
+  fs2.writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: {} }, null, 4), { encoding: "utf-8" });
+  return true;
+};
+var ensureAppJson = (repoPath) => {
+  const appJsonPath = path2.join(repoPath, ".app.json");
+  if (fs2.existsSync(appJsonPath)) {
+    return false;
   }
-  return valid;
+  fs2.writeFileSync(appJsonPath, JSON.stringify({ apps: {} }, null, 4), { encoding: "utf-8" });
+  return true;
 };
-var scaffoldCommand = async (localPath, options = {}) => {
+var scaffoldCommand = async (localPath) => {
   try {
     let targetPath = null;
     if (localPath != null) {
@@ -502,82 +692,71 @@ var scaffoldCommand = async (localPath, options = {}) => {
       if (configManager.repo_path != null) {
         targetPath = configManager.repo_path;
       } else {
-        console.error(chalk2.red("No path provided and no repo registered. Please provide a path."));
+        console.error(chalk3.red("No path provided and no repo registered. Please provide a path."));
         process.exit(1);
       }
     }
     if (fs2.existsSync(targetPath) === false || fs2.statSync(targetPath).isDirectory() === false) {
-      console.error(chalk2.red(`Invalid directory path: '${targetPath}'`));
+      console.error(chalk3.red(`Invalid directory path: '${targetPath}'`));
       process.exit(1);
     }
-    if (options.force !== true) {
-      console.log(chalk2.dim(`Checking repo structure at: ${targetPath}`));
-    }
-    const valid = options.force === true ? false : await printStructure(targetPath);
-    if (valid) {
-      console.log(chalk2.green("Repo structure is valid."));
-      return true;
-    }
-    if (!valid) {
-      if (options.force !== true) {
-        const proceed = await confirm({
-          message: "Some directories are missing. Scaffold them now?",
-          default: true
-        });
-        if (proceed === false) {
-          console.log(chalk2.yellow("Scaffold skipped."));
-          return false;
-        }
-      }
-      const created = [];
+    console.log(chalk3.dim(`Scaffolding: ${targetPath}
+`));
+    const writeGuide = await confirm({
+      message: "Generate SET_PROMPT_GUIDE.md? (reference doc for writing prompts)",
+      default: true
+    });
+    if (writeGuide) {
       const guideMdPath = path2.join(targetPath, "SET_PROMPT_GUIDE.md");
       fs2.writeFileSync(guideMdPath, SET_PROMPT_GUIDE, { encoding: "utf-8", flag: "w" });
-      created.push("  SET_PROMPT_GUIDE.md");
-      for (const dirName of PROMPT_DIR_NAMES) {
-        const dirPath = path2.join(targetPath, dirName);
-        if (fs2.existsSync(dirPath)) {
-          console.warn(chalk2.yellow(`Directory already exists: '${dirName}' (skipping)`));
-        } else {
-          fs2.mkdirSync(dirPath, { recursive: true });
-          created.push(`  ${dirName}/`);
-        }
-        const gitkeepPath = path2.join(dirPath, ".gitkeep");
-        if (!fs2.existsSync(gitkeepPath)) {
-          fs2.writeFileSync(gitkeepPath, "", { encoding: "utf-8" });
-          if (!created.includes(`  ${dirName}/`)) {
-            created.push(`  ${dirName}/.gitkeep`);
-          }
-        }
+      console.log(`${TAB}${chalk3.green("\u2713")} SET_PROMPT_GUIDE.md`);
+    }
+    for (const dirName of PROMPT_DIR_NAMES) {
+      const dirPath = path2.join(targetPath, dirName);
+      if (fs2.existsSync(dirPath)) {
+        console.log(`${TAB}${chalk3.dim("\u2713")} ${dirName}/`);
+      } else {
+        fs2.mkdirSync(dirPath, { recursive: true });
+        console.log(`${TAB}${chalk3.green("+")} ${dirName}/`);
       }
-      if (created.length > 0) {
-        console.log(chalk2.green("Created:"));
-        created.forEach((line) => console.log(line));
+      const gitkeepPath = path2.join(dirPath, ".gitkeep");
+      if (!fs2.existsSync(gitkeepPath)) {
+        fs2.writeFileSync(gitkeepPath, "", { encoding: "utf-8" });
       }
     }
+    ensureClaudePluginManifest(targetPath);
+    console.log(`${TAB}${chalk3.green("\u2713")} .claude-plugin/plugin.json`);
+    ensureCodexPluginManifest(targetPath);
+    console.log(`${TAB}${chalk3.green("\u2713")} .codex-plugin/plugin.json`);
+    console.log(`${TAB}${ensureMcpJson(targetPath) ? chalk3.green("+") : chalk3.dim("\u2713")} mcp.json`);
+    console.log(`${TAB}${ensureAppJson(targetPath) ? chalk3.green("+") : chalk3.dim("\u2713")} .app.json`);
+    console.log(chalk3.green("\nScaffold complete."));
     return true;
   } catch (ex) {
-    console.error(chalk2.red(`Failed to scaffold repo structure: ${ex.message}`), ex);
+    console.error(chalk3.red(`Failed to scaffold repo structure: ${ex.message}`), ex);
     throw ex;
   }
 };
 
 // src/commands/install-command.ts
 var cloneRepo = async (remoteUrl) => {
-  const proceed = await confirm2({
-    message: `Clone and register "${remoteUrl}"?`,
-    default: true
-  });
-  if (proceed == false) {
-    console.log(chalk3.yellow("Cancelled."));
-    return false;
-  }
   const localPath = path3.join(HOME_DIR, "repo");
+  let backupPath = null;
   if (fs3.existsSync(localPath) == true) {
-    console.warn(chalk3.yellow(`Existing repo found. Backing up before proceeding.`));
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = path3.join(HOME_DIR, `repo.bak.${timestamp}`);
-    fs3.renameSync(localPath, backupPath);
-    console.log(chalk3.dim(`  Backed up to: ${backupPath}`));
+    backupPath = path3.join(HOME_DIR, `repo.bak.${timestamp}`);
+    try {
+      fs3.renameSync(localPath, backupPath);
+      console.log(chalk4.yellow("  backed up") + chalk4.dim(` existing repo \u2192 ${backupPath}`));
+    } catch (ex) {
+      if (ex.code === "EPERM") {
+        console.error(chalk4.red("\u274C Cannot rename existing repo \u2014 it may be open in another process."));
+        console.log(chalk4.dim(`   Close any editors or terminals using: ${localPath}`));
+      } else {
+        console.error(chalk4.red(`\u274C Failed to backup existing repo: ${ex.message}`));
+      }
+      return false;
+    }
   }
   fs3.mkdirSync(path3.dirname(localPath), { recursive: true });
   console.log(`Cloning ${remoteUrl}...`);
@@ -587,11 +766,15 @@ var cloneRepo = async (remoteUrl) => {
     process.exit(1);
   }
   console.log("\u2705 Cloned successfully.");
+  if (backupPath != null) {
+    fs3.rmSync(backupPath, { recursive: true, force: true });
+    console.log(chalk4.red("  removed") + chalk4.dim(` backup \u2192 ${backupPath}`));
+  }
   await scaffoldCommand(localPath, { force: true });
   configManager.repo_path = localPath;
   configManager.remote_url = remoteUrl;
   if (configManager.save() === false) {
-    console.error(chalk3.red("Failed to save config."));
+    console.error(chalk4.red("Failed to save config."));
     return false;
   }
   return true;
@@ -599,97 +782,81 @@ var cloneRepo = async (remoteUrl) => {
 var installCommand = async (target) => {
   try {
     if (isGitUrl(target) === false) {
-      console.error(chalk3.red("\u274C Only remote git URLs are supported."));
-      console.log(chalk3.dim("   Example: set-prompt install https://github.com/you/my-prompts"));
+      console.error(chalk4.red("\u274C Only remote git URLs are supported."));
+      console.log(chalk4.dim("   Example: set-prompt install https://github.com/you/my-prompts"));
       process.exit(1);
     }
+    const normalizeUrl = (url) => url.replace(/\.git$/, "").toLowerCase();
+    if (configManager.repo_path != null) {
+      if (normalizeUrl(configManager.remote_url ?? "") === normalizeUrl(target)) {
+        console.error(chalk4.red(`\u274C Already installed from the same URL: ${target}`));
+        console.log(chalk4.dim("   Use `set-prompt update` to pull the latest changes."));
+        return false;
+      }
+      console.warn(chalk4.yellow(`\u26A0 Switching repo: ${configManager.remote_url} \u2192 ${target}`));
+      const proceed = await confirm2({ message: "Replace existing installation?", default: false });
+      if (!proceed) {
+        console.log(chalk4.yellow("Cancelled."));
+        return false;
+      }
+    } else {
+      const proceed = await confirm2({ message: `Clone and register "${target}"?`, default: true });
+      if (!proceed) {
+        console.log(chalk4.yellow("Cancelled."));
+        return false;
+      }
+    }
     return await cloneRepo(target);
   } catch (ex) {
-    console.error(chalk3.red(`Unexpected error: ${ex.message}`), ex);
+    console.error(chalk4.red(`Unexpected error: ${ex.message}`), ex);
     process.exit(1);
   }
 };
 
 // src/commands/link-command.ts
+import chalk11 from "chalk";
+import { checkbox } from "@inquirer/prompts";
+
+// src/link/claudecode.ts
 import path4 from "path";
 import fs4 from "fs";
 import os2 from "os";
-import chalk4 from "chalk";
-import { confirm as confirm3, checkbox } from "@inquirer/prompts";
-import { pathExists } from "fs-extra";
-var resolveRepoPath = () => {
-  if (configManager.repo_path == null) {
-    console.error(chalk4.red("\u274C No repo installed."));
-    console.log(chalk4.yellow("Run: set-prompt install <git-url>"));
-    return null;
-  }
-  return configManager.repo_path;
-};
-var PLUGIN_NAME = "set-prompt";
+import chalk5 from "chalk";
+import { confirm as confirm3 } from "@inquirer/prompts";
 var linkClaudeCode = async () => {
   const repoPath = resolveRepoPath();
   if (repoPath == null) {
     return;
   }
-  const setClaudeCodeAssets = async () => {
+  const buildMarketplace = () => {
     try {
-      fs4.mkdirSync(CLAUDE_CODE_DIR, { recursive: true });
       const marketplaceMetaDir = path4.join(CLAUDE_CODE_DIR, ".claude-plugin");
       fs4.mkdirSync(marketplaceMetaDir, { recursive: true });
       const marketplaceJson = {
-        name: PLUGIN_NAME,
+        name: MARKET_NAME,
         owner: { name: os2.userInfo().username },
         metadata: { description: "Managed by set-prompt", version: "1.0.0" },
         plugins: [{ name: PLUGIN_NAME, source: `./plugins/${PLUGIN_NAME}`, description: "Managed by set-prompt" }]
       };
       fs4.writeFileSync(
         path4.join(marketplaceMetaDir, "marketplace.json"),
-        JSON.stringify(marketplaceJson, null, 2),
-        "utf-8"
-      );
-      console.log(chalk4.dim("  \u251C\u2500\u2500 .claude-plugin/"));
-      console.log(chalk4.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk4.green(" \u2713"));
-      const pluginDir = path4.join(CLAUDE_CODE_DIR, "plugins", PLUGIN_NAME);
-      fs4.mkdirSync(pluginDir, { recursive: true });
-      console.log(chalk4.dim("  \u2514\u2500\u2500 plugins/"));
-      console.log(chalk4.dim(`      \u2514\u2500\u2500 ${PLUGIN_NAME}/`));
-      const pluginMetaDir = path4.join(pluginDir, ".claude-plugin");
-      fs4.mkdirSync(pluginMetaDir, { recursive: true });
-      const pluginJson = {
-        name: PLUGIN_NAME,
-        version: "1.0.0",
-        description: "Managed by set-prompt",
-        author: { name: path4.basename(repoPath) }
-      };
-      fs4.writeFileSync(
-        path4.join(pluginMetaDir, "plugin.json"),
-        JSON.stringify(pluginJson, null, 2),
+        JSON.stringify(marketplaceJson, null, 4),
         "utf-8"
       );
-      console.log(chalk4.dim("          \u251C\u2500\u2500 .claude-plugin/"));
-      console.log(chalk4.dim("          \u2502   \u2514\u2500\u2500 plugin.json") + chalk4.green(" \u2713"));
-      const linked = [];
-      for (const dir of AGENT_PROMPT_DIRS["claudecode" /* CLAUDECODE */]) {
-        const src = path4.join(repoPath, dir);
-        const dest = path4.join(pluginDir, dir);
-        if (await pathExists(src) === false) {
-          continue;
-        }
-        if (fs4.existsSync(dest)) {
-          fs4.rmSync(dest, { recursive: true, force: true });
-        }
-        const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs4.symlinkSync(src, dest, symlinkType);
-        linked.push({ dir, src });
-      }
-      for (const { dir, src } of linked) {
-        const isLast = linked[linked.length - 1].dir === dir;
-        const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-        console.log(chalk4.dim(`          ${branch} `) + chalk4.bold(`${dir}/`) + chalk4.dim(` \u2192 ${src}`) + chalk4.green(" \u2713"));
+      console.log(chalk5.dim("  \u251C\u2500\u2500 .claude-plugin/"));
+      console.log(chalk5.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk5.green(" \u2713"));
+      const pluginLink = path4.join(CLAUDE_CODE_DIR, "plugins", PLUGIN_NAME);
+      fs4.mkdirSync(path4.dirname(pluginLink), { recursive: true });
+      if (fs4.existsSync(pluginLink)) {
+        fs4.rmSync(pluginLink, { recursive: true, force: true });
       }
+      const symlinkType = process.platform === "win32" ? "junction" : "dir";
+      fs4.symlinkSync(repoPath, pluginLink, symlinkType);
+      console.log(chalk5.dim("  \u2514\u2500\u2500 plugins/"));
+      console.log(chalk5.dim(`      \u2514\u2500\u2500 ${PLUGIN_NAME}/`) + chalk5.dim(` \u2192 ${repoPath}`) + chalk5.green(" \u2713"));
       return true;
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to build plugin structure: ${ex.message}`));
+      console.error(chalk5.red(`\u274C Failed to build marketplace structure: ${ex.message}`));
       return false;
     }
   };
@@ -704,21 +871,21 @@ var linkClaudeCode = async () => {
           if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
             settings = parsed;
           } else {
-            console.warn(chalk4.yellow("  \u26A0 settings.json has unexpected format \u2014 proceeding with caution"));
+            console.warn(chalk5.yellow("  \u26A0 settings.json has unexpected format \u2014 proceeding with caution"));
           }
         } catch {
-          console.warn(chalk4.yellow("  \u26A0 Failed to parse settings.json \u2014 will not overwrite existing file"));
-          console.error(chalk4.red("\u274C Could not register plugin. Please add manually."));
+          console.warn(chalk5.yellow("  \u26A0 Failed to parse settings.json \u2014 will not overwrite existing file"));
+          console.error(chalk5.red("\u274C Could not register plugin. Please add manually."));
           return false;
         }
       }
       settings.extraKnownMarketplaces = {
         ...settings.extraKnownMarketplaces,
-        [PLUGIN_NAME]: { source: { source: "directory", path: CLAUDE_CODE_DIR } }
+        [MARKET_NAME]: { source: { source: "directory", path: CLAUDE_CODE_DIR } }
       };
       settings.enabledPlugins = {
         ...settings.enabledPlugins,
-        [`${PLUGIN_NAME}@${PLUGIN_NAME}`]: true
+        [`${PLUGIN_NAME}@${MARKET_NAME}`]: true
       };
       let backupPath = null;
       if (fs4.existsSync(claudeSettingsPath)) {
@@ -727,21 +894,21 @@ var linkClaudeCode = async () => {
         try {
           fs4.copyFileSync(claudeSettingsPath, backupPath);
         } catch (ex) {
-          console.warn(chalk4.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
+          console.warn(chalk5.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
           backupPath = null;
         }
       }
       try {
         fs4.mkdirSync(path4.dirname(claudeSettingsPath), { recursive: true });
-        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
       } catch (ex) {
         if (backupPath !== null) {
           try {
             fs4.copyFileSync(backupPath, claudeSettingsPath);
             fs4.unlinkSync(backupPath);
-            console.warn(chalk4.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+            console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
           } catch {
-            console.error(chalk4.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+            console.error(chalk5.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
           }
         }
         throw ex;
@@ -753,60 +920,209 @@ var linkClaudeCode = async () => {
         }
       }
       console.log(`\u2705 Registered to Claude Code settings.`);
-      console.log(chalk4.dim(`   ${claudeSettingsPath}`));
+      console.log(chalk5.dim(`   ${claudeSettingsPath}`));
       return true;
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to update settings.json: ${ex.message}`));
-      console.log(chalk4.dim("   Please add the plugin manually via Claude Code /plugins."));
+      console.error(chalk5.red(`\u274C Failed to update settings.json: ${ex.message}`));
+      console.log(chalk5.dim("   Please add the plugin manually via Claude Code /plugins."));
       return false;
     }
   };
-  console.log(chalk4.green(`
+  const patchInstalledPlugins = () => {
+    const installPath = repoPath;
+    const installedPluginsPath = path4.join(os2.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const pluginKey = `${PLUGIN_NAME}@${MARKET_NAME}`;
+    try {
+      let data = { version: 2, plugins: {} };
+      if (fs4.existsSync(installedPluginsPath)) {
+        try {
+          data = JSON.parse(fs4.readFileSync(installedPluginsPath, "utf-8"));
+        } catch {
+        }
+      }
+      if (data.plugins == null) {
+        data.plugins = {};
+      }
+      data.plugins[pluginKey] = [
+        {
+          scope: "user",
+          installPath,
+          version: "1.0.0",
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+      fs4.mkdirSync(path4.dirname(installedPluginsPath), { recursive: true });
+      fs4.writeFileSync(installedPluginsPath, JSON.stringify(data, null, 4), "utf-8");
+      console.log(`\u2705 Patched installed_plugins.json \u2192 installPath points to source.`);
+      console.log(chalk5.dim(`   ${installPath}`));
+    } catch (ex) {
+      console.warn(chalk5.yellow(`  \u26A0 Could not patch installed_plugins.json: ${ex.message}`));
+    }
+  };
+  console.log(chalk5.green(`
 Setting up Claude Code plugin...`));
-  console.log(chalk4.dim(CLAUDE_CODE_DIR));
-  const structureOk = await setClaudeCodeAssets();
-  if (structureOk === false) {
+  console.log(chalk5.dim(CLAUDE_CODE_DIR));
+  const marketplaceOk = buildMarketplace();
+  if (marketplaceOk === false) {
     return;
   }
   const settingsOk = registerToClaudeSettings();
   if (settingsOk === false) {
     return;
   }
+  patchInstalledPlugins();
   configManager.claude_code = { path: CLAUDE_CODE_DIR };
   configManager.save();
 };
+var unlinkClaudeCode = async (force = false) => {
+  if (!force) {
+    const ok = await confirm3({
+      message: `Remove Claude Code plugin dir (${CLAUDE_CODE_DIR}) and settings entries?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk5.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk5.red(`
+Removing Claude Code plugin...`));
+  console.log(chalk5.dim(CLAUDE_CODE_DIR));
+  const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
+  if (fs4.existsSync(claudeSettingsPath)) {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
+      fs4.copyFileSync(claudeSettingsPath, backupPath);
+      const settings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
+      if (settings?.extraKnownMarketplaces?.[MARKET_NAME] !== void 0) {
+        delete settings.extraKnownMarketplaces[MARKET_NAME];
+      }
+      if (settings?.enabledPlugins?.[`${PLUGIN_NAME}@${MARKET_NAME}`] !== void 0) {
+        delete settings.enabledPlugins[`${PLUGIN_NAME}@${MARKET_NAME}`];
+      }
+      try {
+        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
+        fs4.unlinkSync(backupPath);
+        console.log(chalk5.red("  removed") + chalk5.dim(` set-prompt entries from: ${claudeSettingsPath}`));
+      } catch (ex) {
+        fs4.copyFileSync(backupPath, claudeSettingsPath);
+        fs4.unlinkSync(backupPath);
+        console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+      }
+    } catch (ex) {
+      console.error(chalk5.red(`  \u274C Failed to clean up settings.json: ${ex.message}`));
+    }
+  }
+  const claudePluginsDir = path4.join(os2.homedir(), ".claude", "plugins");
+  const installedPluginsPath = path4.join(claudePluginsDir, "installed_plugins.json");
+  if (fs4.existsSync(installedPluginsPath)) {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${installedPluginsPath}.bak.${timestamp}`;
+      fs4.copyFileSync(installedPluginsPath, backupPath);
+      const installed = JSON.parse(fs4.readFileSync(installedPluginsPath, "utf-8"));
+      if (installed?.plugins && typeof installed.plugins === "object") {
+        for (const key of Object.keys(installed.plugins)) {
+          if (key.endsWith(`@${MARKET_NAME}`)) {
+            delete installed.plugins[key];
+          }
+        }
+      }
+      try {
+        fs4.writeFileSync(installedPluginsPath, JSON.stringify(installed, null, 4), "utf-8");
+        fs4.unlinkSync(backupPath);
+        console.log(chalk5.red("  removed") + chalk5.dim(` set-prompt entries from: ${installedPluginsPath}`));
+      } catch (ex) {
+        fs4.copyFileSync(backupPath, installedPluginsPath);
+        fs4.unlinkSync(backupPath);
+        console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back installed_plugins.json."));
+      }
+    } catch (ex) {
+      console.error(chalk5.red(`  \u274C Failed to clean up installed_plugins.json: ${ex.message}`));
+    }
+  }
+  const knownMarketplacesPath = path4.join(claudePluginsDir, "known_marketplaces.json");
+  if (fs4.existsSync(knownMarketplacesPath)) {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${knownMarketplacesPath}.bak.${timestamp}`;
+      fs4.copyFileSync(knownMarketplacesPath, backupPath);
+      const marketplaces = JSON.parse(fs4.readFileSync(knownMarketplacesPath, "utf-8"));
+      if (marketplaces?.[MARKET_NAME] !== void 0) {
+        delete marketplaces[MARKET_NAME];
+      }
+      try {
+        fs4.writeFileSync(knownMarketplacesPath, JSON.stringify(marketplaces, null, 4), "utf-8");
+        fs4.unlinkSync(backupPath);
+        console.log(chalk5.red("  removed") + chalk5.dim(` set-prompt entry from: ${knownMarketplacesPath}`));
+      } catch (ex) {
+        fs4.copyFileSync(backupPath, knownMarketplacesPath);
+        fs4.unlinkSync(backupPath);
+        console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back known_marketplaces.json."));
+      }
+    } catch (ex) {
+      console.error(chalk5.red(`  \u274C Failed to clean up known_marketplaces.json: ${ex.message}`));
+    }
+  }
+  if (fs4.existsSync(CLAUDE_CODE_DIR)) {
+    fs4.rmSync(CLAUDE_CODE_DIR, { recursive: true, force: true });
+    console.log(chalk5.red("  removed") + chalk5.dim(`: ${CLAUDE_CODE_DIR}`));
+  }
+  configManager.claude_code = null;
+  configManager.save();
+};
+
+// src/link/roocode.ts
+import path5 from "path";
+import fs5 from "fs";
+import chalk6 from "chalk";
+import { confirm as confirm4 } from "@inquirer/prompts";
+import { pathExists } from "fs-extra";
 var linkRooCode = async () => {
   const repoPath = resolveRepoPath();
   if (repoPath == null) {
     return;
   }
-  console.log(chalk4.green(`
+  console.log(chalk6.green(`
 Setting up RooCode integration...`));
-  console.log(chalk4.dim(ROO_DIR));
+  console.log(chalk6.dim(ROO_DIR));
   const roocodeDirs = AGENT_PROMPT_DIRS["roocode" /* ROOCODE */];
   const backupExistingRooCodeFiles = async () => {
     try {
-      fs4.mkdirSync(ROO_DIR, { recursive: true });
+      fs5.mkdirSync(ROO_DIR, { recursive: true });
       const dirsToBackup = [];
       for (const dir of roocodeDirs) {
-        const target = path4.join(ROO_DIR, dir);
-        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false) {
+        const target = path5.join(ROO_DIR, dir);
+        if (fs5.existsSync(target) && fs5.lstatSync(target).isSymbolicLink() === false && fs5.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
-      fs4.mkdirSync(ROO_BACKUP_DIR, { recursive: true });
+      console.log(chalk6.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+      for (const dir of dirsToBackup) {
+        console.log(chalk6.dim(`    - ${path5.join(ROO_DIR, dir)}`));
+      }
+      console.log(chalk6.yellow(`  They will be backed up to: `) + chalk6.dim(ROO_BACKUP_DIR));
+      const ok = await confirm4({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk6.yellow("Skipped RooCode linking."));
+        return false;
+      }
+      fs5.mkdirSync(ROO_BACKUP_DIR, { recursive: true });
       for (const dir of dirsToBackup) {
-        const src = path4.join(ROO_DIR, dir);
-        const dest = path4.join(ROO_BACKUP_DIR, dir);
-        fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  backed up: ${dir}/ \u2192 ${dest}`));
+        const src = path5.join(ROO_DIR, dir);
+        const dest = path5.join(ROO_BACKUP_DIR, dir);
+        fs5.renameSync(src, dest);
+        console.log(chalk6.yellow("  backed up") + chalk6.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk6.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -814,26 +1130,26 @@ Setting up RooCode integration...`));
     try {
       const linked = [];
       for (const dir of roocodeDirs) {
-        const src = path4.join(repoPath, dir);
-        const dest = path4.join(ROO_DIR, dir);
+        const src = path5.join(repoPath, dir);
+        const dest = path5.join(ROO_DIR, dir);
         if (await pathExists(src) === false) {
           continue;
         }
-        if (fs4.existsSync(dest)) {
-          fs4.rmSync(dest, { recursive: true, force: true });
+        if (fs5.existsSync(dest)) {
+          fs5.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs4.symlinkSync(src, dest, symlinkType);
+        fs5.symlinkSync(src, dest, symlinkType);
         linked.push({ dir, src });
       }
       for (const { dir, src } of linked) {
         const isLast = linked[linked.length - 1].dir === dir;
         const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-        console.log(chalk4.dim(`  ${branch} `) + chalk4.bold(`${dir}/`) + chalk4.dim(` \u2192 ${src}`) + chalk4.green(" \u2713"));
+        console.log(chalk6.dim(`  ${branch} `) + chalk6.bold(`${dir}/`) + chalk6.dim(` \u2192 ${src}`) + chalk6.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk6.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -848,38 +1164,97 @@ Setting up RooCode integration...`));
   configManager.roocode = { path: ROO_DIR, backup_path: ROO_BACKUP_DIR };
   configManager.save();
 };
-var linkOpenclaw = async () => {
-  const repoPath = resolveRepoPath();
-  if (repoPath == null) {
-    return;
+var unlinkRooCode = async (force = false) => {
+  if (!force) {
+    const ok = await confirm4({
+      message: `Remove RooCode symlinks from ${ROO_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk6.yellow("Cancelled."));
+      return;
+    }
   }
-  console.log(chalk4.green(`
-Setting up OpenClaw integration...`));
-  console.log(chalk4.dim(OPENCLAW_DIR));
-  const openclawDirs = AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */];
-  const backupExistingOpenclawFiles = async () => {
+  console.log(chalk6.red(`
+Removing RooCode integration...`));
+  console.log(chalk6.dim(ROO_DIR));
+  const backupPath = configManager.roocode?.backup_path ?? ROO_BACKUP_DIR;
+  for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
+    const target = path5.join(ROO_DIR, dir);
+    if (fs5.existsSync(target) && fs5.lstatSync(target).isSymbolicLink()) {
+      fs5.unlinkSync(target);
+      console.log(chalk6.red("  removed symlink") + chalk6.dim(`: ${target}`));
+    }
+  }
+  if (fs5.existsSync(backupPath)) {
     try {
-      fs4.mkdirSync(OPENCLAW_DIR, { recursive: true });
-      const dirsToBackup = [];
+      for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
+        const src = path5.join(backupPath, dir);
+        const dest = path5.join(ROO_DIR, dir);
+        if (!fs5.existsSync(src)) {
+          continue;
+        }
+        fs5.renameSync(src, dest);
+        console.log(chalk6.green("  restored") + chalk6.dim(`: ${dir}/`));
+      }
+      fs5.rmdirSync(backupPath);
+    } catch (ex) {
+      console.error(chalk6.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
+    }
+  }
+  configManager.roocode = null;
+  configManager.save();
+};
+
+// src/link/openclaw.ts
+import path6 from "path";
+import fs6 from "fs";
+import chalk7 from "chalk";
+import { confirm as confirm5 } from "@inquirer/prompts";
+import { pathExists as pathExists2 } from "fs-extra";
+var linkOpenclaw = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
+  }
+  console.log(chalk7.green(`
+Setting up OpenClaw integration...`));
+  console.log(chalk7.dim(OPENCLAW_DIR));
+  const openclawDirs = AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */];
+  const backupExistingOpenclawFiles = async () => {
+    try {
+      fs6.mkdirSync(OPENCLAW_DIR, { recursive: true });
+      const dirsToBackup = [];
       for (const dir of openclawDirs) {
-        const target = path4.join(OPENCLAW_DIR, dir);
-        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false) {
+        const target = path6.join(OPENCLAW_DIR, dir);
+        if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink() === false && fs6.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
-      fs4.mkdirSync(OPENCLAW_BACKUP_DIR, { recursive: true });
+      console.log(chalk7.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
       for (const dir of dirsToBackup) {
-        const src = path4.join(OPENCLAW_DIR, dir);
-        const dest = path4.join(OPENCLAW_BACKUP_DIR, dir);
-        fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  backed up: ${dir}/ \u2192 ${dest}`));
+        console.log(chalk7.dim(`    - ${path6.join(OPENCLAW_DIR, dir)}`));
+      }
+      console.log(chalk7.yellow(`  They will be backed up to: `) + chalk7.dim(OPENCLAW_BACKUP_DIR));
+      const ok = await confirm5({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk7.yellow("Skipped OpenClaw linking."));
+        return false;
+      }
+      fs6.mkdirSync(OPENCLAW_BACKUP_DIR, { recursive: true });
+      for (const dir of dirsToBackup) {
+        const src = path6.join(OPENCLAW_DIR, dir);
+        const dest = path6.join(OPENCLAW_BACKUP_DIR, dir);
+        fs6.renameSync(src, dest);
+        console.log(chalk7.yellow("  backed up") + chalk7.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk7.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -887,26 +1262,26 @@ Setting up OpenClaw integration...`));
     try {
       const linked = [];
       for (const dir of openclawDirs) {
-        const src = path4.join(repoPath, dir);
-        const dest = path4.join(OPENCLAW_DIR, dir);
-        if (await pathExists(src) === false) {
+        const src = path6.join(repoPath, dir);
+        const dest = path6.join(OPENCLAW_DIR, dir);
+        if (await pathExists2(src) === false) {
           continue;
         }
-        if (fs4.existsSync(dest)) {
-          fs4.rmSync(dest, { recursive: true, force: true });
+        if (fs6.existsSync(dest)) {
+          fs6.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs4.symlinkSync(src, dest, symlinkType);
+        fs6.symlinkSync(src, dest, symlinkType);
         linked.push({ dir, src });
       }
       for (const { dir, src } of linked) {
         const isLast = linked[linked.length - 1].dir === dir;
         const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-        console.log(chalk4.dim(`  ${branch} `) + chalk4.bold(`${dir}/`) + chalk4.dim(` \u2192 ${src}`) + chalk4.green(" \u2713"));
+        console.log(chalk7.dim(`  ${branch} `) + chalk7.bold(`${dir}/`) + chalk7.dim(` \u2192 ${src}`) + chalk7.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk7.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -921,261 +1296,544 @@ Setting up OpenClaw integration...`));
   configManager.openclaw = { path: OPENCLAW_DIR, backup_path: OPENCLAW_BACKUP_DIR };
   configManager.save();
 };
-var linkCodex = async () => {
-  if (resolveRepoPath() == null) {
-    return;
-  }
-  console.log(chalk4.yellow("Codex integration is not yet implemented."));
-};
-var unlinkClaudeCode = async (force = false) => {
-  if (!force) {
-    const ok = await confirm3({
-      message: `Remove Claude Code plugin dir (${CLAUDE_CODE_DIR}) and settings entries?`,
-      default: false
-    });
-    if (!ok) {
-      console.log(chalk4.yellow("Cancelled."));
-      return;
-    }
-  }
-  const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
-  if (fs4.existsSync(claudeSettingsPath)) {
-    try {
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-      const backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
-      fs4.copyFileSync(claudeSettingsPath, backupPath);
-      const settings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
-      if (settings?.extraKnownMarketplaces?.[PLUGIN_NAME] !== void 0) {
-        delete settings.extraKnownMarketplaces[PLUGIN_NAME];
-      }
-      if (settings?.enabledPlugins?.[`${PLUGIN_NAME}@${PLUGIN_NAME}`] !== void 0) {
-        delete settings.enabledPlugins[`${PLUGIN_NAME}@${PLUGIN_NAME}`];
-      }
-      try {
-        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
-        fs4.unlinkSync(backupPath);
-        console.log(chalk4.dim(`  removed set-prompt entries from: ${claudeSettingsPath}`));
-      } catch (ex) {
-        fs4.copyFileSync(backupPath, claudeSettingsPath);
-        fs4.unlinkSync(backupPath);
-        console.warn(chalk4.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
-      }
-    } catch (ex) {
-      console.error(chalk4.red(`  \u274C Failed to clean up settings.json: ${ex.message}`));
-    }
-  }
-  if (fs4.existsSync(CLAUDE_CODE_DIR)) {
-    fs4.rmSync(CLAUDE_CODE_DIR, { recursive: true, force: true });
-    console.log(chalk4.dim(`  removed: ${CLAUDE_CODE_DIR}`));
-  }
-  configManager.claude_code = null;
-  configManager.save();
-};
-var unlinkRooCode = async (force = false) => {
+var unlinkOpenclaw = async (force = false) => {
   if (!force) {
-    const ok = await confirm3({
-      message: `Remove RooCode symlinks from ${ROO_DIR}?`,
+    const ok = await confirm5({
+      message: `Remove OpenClaw symlinks from ${OPENCLAW_DIR}?`,
       default: false
     });
     if (!ok) {
-      console.log(chalk4.yellow("Cancelled."));
+      console.log(chalk7.yellow("Cancelled."));
       return;
     }
   }
-  const backupPath = configManager.roocode?.backup_path ?? ROO_BACKUP_DIR;
-  for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
-    const target = path4.join(ROO_DIR, dir);
-    if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
-      fs4.unlinkSync(target);
-      console.log(chalk4.dim(`  removed symlink: ${target}`));
+  console.log(chalk7.red(`
+Removing OpenClaw integration...`));
+  console.log(chalk7.dim(OPENCLAW_DIR));
+  const backupPath = configManager.openclaw?.backup_path ?? OPENCLAW_BACKUP_DIR;
+  for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
+    const target = path6.join(OPENCLAW_DIR, dir);
+    if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink()) {
+      fs6.unlinkSync(target);
+      console.log(chalk7.red("  removed symlink") + chalk7.dim(`: ${target}`));
     }
   }
-  if (fs4.existsSync(backupPath)) {
+  if (fs6.existsSync(backupPath)) {
     try {
-      for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
-        const src = path4.join(backupPath, dir);
-        const dest = path4.join(ROO_DIR, dir);
-        if (!fs4.existsSync(src)) {
+      for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
+        const src = path6.join(backupPath, dir);
+        const dest = path6.join(OPENCLAW_DIR, dir);
+        if (!fs6.existsSync(src)) {
           continue;
         }
-        fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  restored: ${dir}/`));
+        fs6.renameSync(src, dest);
+        console.log(chalk7.green("  restored") + chalk7.dim(`: ${dir}/`));
       }
-      fs4.rmdirSync(backupPath);
+      fs6.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk4.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
+      console.error(chalk7.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
     }
   }
-  configManager.roocode = null;
+  configManager.openclaw = null;
   configManager.save();
 };
-var unlinkOpenclaw = async (force = false) => {
-  if (!force) {
-    const ok = await confirm3({
-      message: `Remove OpenClaw symlinks from ${OPENCLAW_DIR}?`,
-      default: false
-    });
-    if (!ok) {
-      console.log(chalk4.yellow("Cancelled."));
-      return;
-    }
+
+// src/link/antigravity.ts
+import path7 from "path";
+import fs7 from "fs";
+import chalk8 from "chalk";
+import { confirm as confirm6 } from "@inquirer/prompts";
+import { pathExists as pathExists3 } from "fs-extra";
+var linkAntigravity = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
   }
-  const backupPath = configManager.openclaw?.backup_path ?? OPENCLAW_BACKUP_DIR;
-  for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
-    const target = path4.join(OPENCLAW_DIR, dir);
-    if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
-      fs4.unlinkSync(target);
-      console.log(chalk4.dim(`  removed symlink: ${target}`));
+  console.log(chalk8.green(`
+Setting up Antigravity integration...`));
+  console.log(chalk8.dim(ANTIGRAVITY_DIR));
+  const antigravityDirs = AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */];
+  const backupExistingAntigravityFiles = async () => {
+    try {
+      fs7.mkdirSync(ANTIGRAVITY_DIR, { recursive: true });
+      const dirsToBackup = [];
+      for (const dir of antigravityDirs) {
+        const target = path7.join(ANTIGRAVITY_DIR, dir);
+        if (fs7.existsSync(target) && fs7.lstatSync(target).isSymbolicLink() === false && fs7.readdirSync(target).length > 0) {
+          dirsToBackup.push(dir);
+        }
+      }
+      if (dirsToBackup.length === 0) {
+        return true;
+      }
+      console.log(chalk8.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+      for (const dir of dirsToBackup) {
+        console.log(chalk8.dim(`    - ${path7.join(ANTIGRAVITY_DIR, dir)}`));
+      }
+      console.log(chalk8.yellow(`  They will be backed up to: `) + chalk8.dim(ANTIGRAVITY_BACKUP_DIR));
+      const ok = await confirm6({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk8.yellow("Skipped Antigravity linking."));
+        return false;
+      }
+      fs7.mkdirSync(ANTIGRAVITY_BACKUP_DIR, { recursive: true });
+      for (const dir of antigravityDirs) {
+        const src = path7.join(ANTIGRAVITY_DIR, dir);
+        const dest = path7.join(ANTIGRAVITY_BACKUP_DIR, dir);
+        fs7.renameSync(src, dest);
+        console.log(chalk8.yellow("  backed up") + chalk8.dim(`: ${dir}/ \u2192 ${dest}`));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk8.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      return false;
     }
-  }
-  if (fs4.existsSync(backupPath)) {
+  };
+  const setAntigravityAssets = async () => {
     try {
-      for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
-        const src = path4.join(backupPath, dir);
-        const dest = path4.join(OPENCLAW_DIR, dir);
-        if (!fs4.existsSync(src)) {
+      const linked = [];
+      for (const dir of antigravityDirs) {
+        const src = path7.join(repoPath, dir);
+        const dest = path7.join(ANTIGRAVITY_DIR, dir);
+        if (await pathExists3(src) === false) {
           continue;
         }
-        fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  restored: ${dir}/`));
+        if (fs7.existsSync(dest)) {
+          fs7.rmSync(dest, { recursive: true, force: true });
+        }
+        const symlinkType = process.platform === "win32" ? "junction" : "dir";
+        fs7.symlinkSync(src, dest, symlinkType);
+        linked.push({ dir, src });
       }
-      fs4.rmdirSync(backupPath);
+      for (const { dir, src } of linked) {
+        const isLast = linked[linked.length - 1].dir === dir;
+        const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        console.log(chalk8.dim(`  ${branch} `) + chalk8.bold(`${dir}/`) + chalk8.dim(` \u2192 ${src}`) + chalk8.green(" \u2713"));
+      }
+      return true;
     } catch (ex) {
-      console.error(chalk4.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
+      console.error(chalk8.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      return false;
     }
+  };
+  const backupOk = await backupExistingAntigravityFiles();
+  if (backupOk === false) {
+    return;
   }
-  configManager.openclaw = null;
+  const linkOk = await setAntigravityAssets();
+  if (linkOk === false) {
+    return;
+  }
+  configManager.antigravity = { path: ANTIGRAVITY_DIR, backup_path: ANTIGRAVITY_BACKUP_DIR };
   configManager.save();
 };
 var unlinkAntigravity = async (force = false) => {
   if (!force) {
-    const ok = await confirm3({
+    const ok = await confirm6({
       message: `Remove Antigravity symlinks from ${ANTIGRAVITY_DIR}?`,
       default: false
     });
     if (!ok) {
-      console.log(chalk4.yellow("Cancelled."));
+      console.log(chalk8.yellow("Cancelled."));
       return;
     }
   }
+  console.log(chalk8.red(`
+Removing Antigravity integration...`));
+  console.log(chalk8.dim(ANTIGRAVITY_DIR));
   const backupPath = configManager.antigravity?.backup_path ?? ANTIGRAVITY_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
-    const target = path4.join(ANTIGRAVITY_DIR, dir);
-    if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
-      fs4.unlinkSync(target);
-      console.log(chalk4.dim(`  removed symlink: ${target}`));
+    const target = path7.join(ANTIGRAVITY_DIR, dir);
+    if (fs7.existsSync(target) && fs7.lstatSync(target).isSymbolicLink()) {
+      fs7.unlinkSync(target);
+      console.log(chalk8.red("  removed symlink") + chalk8.dim(`: ${target}`));
     }
   }
-  if (fs4.existsSync(backupPath)) {
+  if (fs7.existsSync(backupPath)) {
     try {
       for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
-        const src = path4.join(backupPath, dir);
-        const dest = path4.join(ANTIGRAVITY_DIR, dir);
-        if (!fs4.existsSync(src)) {
+        const src = path7.join(backupPath, dir);
+        const dest = path7.join(ANTIGRAVITY_DIR, dir);
+        if (!fs7.existsSync(src)) {
           continue;
         }
-        fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  restored: ${dir}/`));
+        fs7.renameSync(src, dest);
+        console.log(chalk8.green("  restored") + chalk8.dim(`: ${dir}/`));
       }
-      fs4.rmdirSync(backupPath);
+      fs7.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk4.red(`  \u274C Failed to restore Antigravity backup: ${ex.message}`));
+      console.error(chalk8.red(`  \u274C Failed to restore Antigravity backup: ${ex.message}`));
     }
   }
   configManager.antigravity = null;
   configManager.save();
 };
-var linkAntigravity = async () => {
+
+// src/link/codex.ts
+import path8 from "path";
+import fs8 from "fs";
+import os3 from "os";
+import chalk9 from "chalk";
+import { confirm as confirm7 } from "@inquirer/prompts";
+import TOML from "smol-toml";
+var CODEX_AGENTS_DIR = path8.join(os3.homedir(), ".agents", "plugins");
+var CODEX_CACHE_DIR = path8.join(os3.homedir(), ".codex", "plugins", "cache");
+var CODEX_MARKETPLACE_NAME = "local-repo";
+var linkCodex = async () => {
   const repoPath = resolveRepoPath();
   if (repoPath == null) {
     return;
   }
-  console.log(chalk4.green(`
-Setting up Antigravity integration...`));
-  console.log(chalk4.dim(ANTIGRAVITY_DIR));
-  const antigravityDirs = AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */];
-  const backupExistingAntigravityFiles = async () => {
+  ensureCodexPluginManifest(repoPath);
+  ensureMcpJson(repoPath);
+  ensureAppJson(repoPath);
+  const registerToMarketplace = () => {
+    const marketplacePath = path8.join(CODEX_AGENTS_DIR, "marketplace.json");
     try {
-      fs4.mkdirSync(ANTIGRAVITY_DIR, { recursive: true });
-      const dirsToBackup = [];
-      for (const dir of antigravityDirs) {
-        const target = path4.join(ANTIGRAVITY_DIR, dir);
-        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false) {
-          dirsToBackup.push(dir);
+      let marketplace = {
+        name: CODEX_MARKETPLACE_NAME,
+        interface: { displayName: "Local Repository" },
+        plugins: []
+      };
+      if (fs8.existsSync(marketplacePath)) {
+        const raw = fs8.readFileSync(marketplacePath, "utf-8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            marketplace = parsed;
+          }
+        } catch {
+          console.warn(chalk9.yellow("  \u26A0 Failed to parse marketplace.json \u2014 will not overwrite existing file"));
+          console.error(chalk9.red("\u274C Could not register plugin. Please add manually."));
+          return false;
         }
       }
-      if (dirsToBackup.length === 0) {
-        return true;
+      if (!Array.isArray(marketplace.plugins)) {
+        marketplace.plugins = [];
       }
-      fs4.mkdirSync(ANTIGRAVITY_BACKUP_DIR, { recursive: true });
-      for (const dir of dirsToBackup) {
-        const src = path4.join(ANTIGRAVITY_DIR, dir);
-        const dest = path4.join(ANTIGRAVITY_BACKUP_DIR, dir);
-        fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  backed up: ${dir}/ \u2192 ${dest}`));
+      marketplace.plugins = marketplace.plugins.filter(
+        (p) => p?.name !== PLUGIN_NAME
+      );
+      const relRepoPath = `./${path8.relative(os3.homedir(), repoPath).replace(/\\/g, "/")}`;
+      marketplace.plugins.push({
+        name: PLUGIN_NAME,
+        source: {
+          source: "local",
+          path: relRepoPath
+        },
+        policy: {
+          installation: "AVAILABLE"
+        },
+        category: "Productivity"
+      });
+      let backupPath = null;
+      if (fs8.existsSync(marketplacePath)) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        backupPath = `${marketplacePath}.bak.${timestamp}`;
+        try {
+          fs8.copyFileSync(marketplacePath, backupPath);
+        } catch (ex) {
+          console.warn(chalk9.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
+          backupPath = null;
+        }
+      }
+      try {
+        fs8.mkdirSync(path8.dirname(marketplacePath), { recursive: true });
+        fs8.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 4), "utf-8");
+      } catch (ex) {
+        if (backupPath !== null) {
+          try {
+            fs8.copyFileSync(backupPath, marketplacePath);
+            fs8.unlinkSync(backupPath);
+            console.warn(chalk9.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+          } catch {
+            console.error(chalk9.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+          }
+        }
+        throw ex;
       }
+      if (backupPath !== null) {
+        try {
+          fs8.unlinkSync(backupPath);
+        } catch {
+        }
+      }
+      console.log(`\u2705 Registered to marketplace.json`);
+      console.log(chalk9.dim(`   ${marketplacePath}`));
       return true;
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk9.red(`\u274C Failed to update marketplace.json: ${ex.message}`));
       return false;
     }
   };
-  const setAntigravityAssets = async () => {
+  const patchPluginCache = () => {
+    const cachePath = path8.join(CODEX_CACHE_DIR, CODEX_MARKETPLACE_NAME, PLUGIN_NAME, "1.0.0");
     try {
-      const linked = [];
-      for (const dir of antigravityDirs) {
-        const src = path4.join(repoPath, dir);
-        const dest = path4.join(ANTIGRAVITY_DIR, dir);
-        if (await pathExists(src) === false) {
-          continue;
-        }
-        if (fs4.existsSync(dest)) {
-          fs4.rmSync(dest, { recursive: true, force: true });
-        }
-        const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs4.symlinkSync(src, dest, symlinkType);
-        linked.push({ dir, src });
+      fs8.mkdirSync(path8.dirname(cachePath), { recursive: true });
+      if (fs8.existsSync(cachePath)) {
+        fs8.rmSync(cachePath, { recursive: true, force: true });
       }
-      for (const { dir, src } of linked) {
-        const isLast = linked[linked.length - 1].dir === dir;
-        const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
-        console.log(chalk4.dim(`  ${branch} `) + chalk4.bold(`${dir}/`) + chalk4.dim(` \u2192 ${src}`) + chalk4.green(" \u2713"));
+      const symlinkType = process.platform === "win32" ? "junction" : "dir";
+      fs8.symlinkSync(repoPath, cachePath, symlinkType);
+      console.log(`\u2705 Patched plugin cache.`);
+      console.log(chalk9.dim(`   ${cachePath}`) + chalk9.dim(" \u2192 ") + chalk9.dim(repoPath));
+    } catch (ex) {
+      console.warn(chalk9.yellow(`  \u26A0 Could not patch plugin cache: ${ex.message}`));
+    }
+  };
+  const enableInConfig = () => {
+    const configPath = path8.join(os3.homedir(), ".codex", "config.toml");
+    const pluginKey = `${PLUGIN_NAME}@${CODEX_MARKETPLACE_NAME}`;
+    try {
+      let config = {};
+      if (fs8.existsSync(configPath)) {
+        config = TOML.parse(fs8.readFileSync(configPath, "utf-8"));
       }
-      return true;
+      if (config.plugins == null) {
+        config.plugins = {};
+      }
+      config.plugins[pluginKey] = { enabled: true };
+      fs8.mkdirSync(path8.dirname(configPath), { recursive: true });
+      fs8.writeFileSync(configPath, TOML.stringify(config), "utf-8");
+      console.log(`\u2705 Enabled plugin in config.toml`);
+      console.log(chalk9.dim(`   ${configPath}`));
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to create symlinks: ${ex.message}`));
-      return false;
+      console.warn(chalk9.yellow(`  \u26A0 Could not update config.toml: ${ex.message}`));
     }
   };
-  const backupOk = await backupExistingAntigravityFiles();
-  if (backupOk === false) {
+  console.log(chalk9.green(`
+Setting up Codex plugin...`));
+  const marketplaceOk = registerToMarketplace();
+  if (marketplaceOk === false) {
     return;
   }
-  const linkOk = await setAntigravityAssets();
-  if (linkOk === false) {
+  patchPluginCache();
+  enableInConfig();
+  configManager.codex = { path: CODEX_DIR };
+  configManager.save();
+};
+var unlinkCodex = async (force = false) => {
+  if (!force) {
+    const ok = await confirm7({
+      message: `Remove Codex plugin and marketplace entries?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk9.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk9.red(`
+Removing Codex plugin...`));
+  const marketplacePath = path8.join(CODEX_AGENTS_DIR, "marketplace.json");
+  if (fs8.existsSync(marketplacePath)) {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${marketplacePath}.bak.${timestamp}`;
+      fs8.copyFileSync(marketplacePath, backupPath);
+      const marketplace = JSON.parse(fs8.readFileSync(marketplacePath, "utf-8"));
+      if (Array.isArray(marketplace?.plugins)) {
+        marketplace.plugins = marketplace.plugins.filter(
+          (p) => p?.name !== PLUGIN_NAME
+        );
+      }
+      try {
+        fs8.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 4), "utf-8");
+        fs8.unlinkSync(backupPath);
+        console.log(chalk9.red("  removed") + chalk9.dim(` ${PLUGIN_NAME} from: ${marketplacePath}`));
+      } catch (ex) {
+        fs8.copyFileSync(backupPath, marketplacePath);
+        fs8.unlinkSync(backupPath);
+        console.warn(chalk9.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+      }
+    } catch (ex) {
+      console.error(chalk9.red(`  \u274C Failed to clean up marketplace.json: ${ex.message}`));
+    }
+  }
+  const configPath = path8.join(os3.homedir(), ".codex", "config.toml");
+  if (fs8.existsSync(configPath)) {
+    try {
+      const config = TOML.parse(fs8.readFileSync(configPath, "utf-8"));
+      const pluginKey = `${PLUGIN_NAME}@${CODEX_MARKETPLACE_NAME}`;
+      if (config.plugins?.[pluginKey] !== void 0) {
+        delete config.plugins[pluginKey];
+        fs8.writeFileSync(configPath, TOML.stringify(config), "utf-8");
+        console.log(chalk9.red("  removed") + chalk9.dim(` ${pluginKey} from: ${configPath}`));
+      }
+    } catch (ex) {
+      console.error(chalk9.red(`  \u274C Failed to clean up config.toml: ${ex.message}`));
+    }
+  }
+  const cacheMarketDir = path8.join(CODEX_CACHE_DIR, CODEX_MARKETPLACE_NAME);
+  if (fs8.existsSync(cacheMarketDir)) {
+    fs8.rmSync(cacheMarketDir, { recursive: true, force: true });
+    console.log(chalk9.red("  removed") + chalk9.dim(`: ${cacheMarketDir}`));
+  }
+  configManager.codex = null;
+  configManager.save();
+};
+
+// src/link/cursor.ts
+import path9 from "path";
+import fs9 from "fs";
+import chalk10 from "chalk";
+import { confirm as confirm8 } from "@inquirer/prompts";
+import { pathExists as pathExists4 } from "fs-extra";
+var CURSOR_BACKUP_DIR = path9.join(CURSOR_DIR, "SET_PROMPT_BACKUP");
+var linkCursor = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
     return;
   }
-  configManager.antigravity = { path: ANTIGRAVITY_DIR, backup_path: ANTIGRAVITY_BACKUP_DIR };
+  console.log(chalk10.green(`
+Setting up Cursor integration...`));
+  console.log(chalk10.dim(CURSOR_DIR));
+  const cursorDirs = AGENT_PROMPT_DIRS["cursor" /* CURSOR */];
+  const dirsToBackup = [];
+  for (const dir of cursorDirs) {
+    const target = path9.join(CURSOR_DIR, dir);
+    if (fs9.existsSync(target) && fs9.lstatSync(target).isSymbolicLink() === false && fs9.readdirSync(target).length > 0) {
+      dirsToBackup.push(dir);
+    }
+  }
+  if (dirsToBackup.length > 0) {
+    console.log(chalk10.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+    for (const dir of dirsToBackup) {
+      console.log(chalk10.dim(`    - ${path9.join(CURSOR_DIR, dir)}`));
+    }
+    console.log(chalk10.yellow(`  They will be backed up to: `) + chalk10.dim(CURSOR_BACKUP_DIR));
+    const ok = await confirm8({ message: "Back up existing directories?", default: true });
+    if (!ok) {
+      console.log(chalk10.yellow("Skipped Cursor linking."));
+      return;
+    }
+    fs9.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
+    for (const dir of dirsToBackup) {
+      const src = path9.join(CURSOR_DIR, dir);
+      const dest = path9.join(CURSOR_BACKUP_DIR, dir);
+      fs9.renameSync(src, dest);
+      console.log(chalk10.yellow("  backed up") + chalk10.dim(`: ${dir}/ \u2192 ${dest}`));
+    }
+  }
+  try {
+    const linked = [];
+    for (const dir of cursorDirs) {
+      const src = path9.join(repoPath, dir);
+      const dest = path9.join(CURSOR_DIR, dir);
+      if (await pathExists4(src) === false) {
+        continue;
+      }
+      if (fs9.existsSync(dest)) {
+        fs9.rmSync(dest, { recursive: true, force: true });
+      }
+      const symlinkType = process.platform === "win32" ? "junction" : "dir";
+      fs9.symlinkSync(src, dest, symlinkType);
+      linked.push({ dir, src });
+    }
+    for (const { dir, src } of linked) {
+      console.log(chalk10.dim(`  \u251C\u2500\u2500 `) + chalk10.bold(`${dir}/`) + chalk10.dim(` \u2192 ${src}`) + chalk10.green(" \u2713"));
+    }
+    const mcpSrc = path9.join(repoPath, "mcp.json");
+    const mcpDest = path9.join(CURSOR_DIR, "mcp.json");
+    if (fs9.existsSync(mcpSrc)) {
+      if (fs9.existsSync(mcpDest) && fs9.statSync(mcpDest).ino !== fs9.statSync(mcpSrc).ino) {
+        const mcpBackup = path9.join(CURSOR_BACKUP_DIR, "mcp.json");
+        fs9.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
+        fs9.renameSync(mcpDest, mcpBackup);
+        console.log(chalk10.yellow("  backed up") + chalk10.dim(`: mcp.json \u2192 ${mcpBackup}`));
+      }
+      if (fs9.existsSync(mcpDest)) {
+        fs9.unlinkSync(mcpDest);
+      }
+      fs9.linkSync(mcpSrc, mcpDest);
+      console.log(chalk10.dim(`  \u2514\u2500\u2500 `) + chalk10.bold("mcp.json") + chalk10.dim(` \u21D4 ${mcpSrc}`) + chalk10.green(" \u2713"));
+    }
+  } catch (ex) {
+    console.error(chalk10.red(`\u274C Failed to set up Cursor: ${ex.message}`));
+    return;
+  }
+  configManager.cursor = { path: CURSOR_DIR, backup_path: CURSOR_BACKUP_DIR };
   configManager.save();
 };
+var unlinkCursor = async (force = false) => {
+  if (!force) {
+    const ok = await confirm8({
+      message: `Remove Cursor symlinks from ${CURSOR_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk10.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk10.red(`
+Removing Cursor integration...`));
+  console.log(chalk10.dim(CURSOR_DIR));
+  const backupPath = configManager.cursor?.backup_path ?? CURSOR_BACKUP_DIR;
+  for (const dir of AGENT_PROMPT_DIRS["cursor" /* CURSOR */]) {
+    const target = path9.join(CURSOR_DIR, dir);
+    if (fs9.existsSync(target) && fs9.lstatSync(target).isSymbolicLink()) {
+      fs9.unlinkSync(target);
+      console.log(chalk10.red("  removed symlink") + chalk10.dim(`: ${target}`));
+    }
+  }
+  const mcpDest = path9.join(CURSOR_DIR, "mcp.json");
+  if (fs9.existsSync(mcpDest)) {
+    fs9.unlinkSync(mcpDest);
+    console.log(chalk10.red("  removed") + chalk10.dim(`: ${mcpDest}`));
+  }
+  if (fs9.existsSync(backupPath)) {
+    try {
+      for (const dir of AGENT_PROMPT_DIRS["cursor" /* CURSOR */]) {
+        const src = path9.join(backupPath, dir);
+        const dest = path9.join(CURSOR_DIR, dir);
+        if (!fs9.existsSync(src)) {
+          continue;
+        }
+        fs9.renameSync(src, dest);
+        console.log(chalk10.green("  restored") + chalk10.dim(`: ${dir}/`));
+      }
+      const mcpBackup = path9.join(backupPath, "mcp.json");
+      if (fs9.existsSync(mcpBackup)) {
+        fs9.renameSync(mcpBackup, mcpDest);
+        console.log(chalk10.green("  restored") + chalk10.dim(`: mcp.json`));
+      }
+      fs9.rmSync(backupPath, { recursive: true, force: true });
+    } catch (ex) {
+      console.error(chalk10.red(`  \u274C Failed to restore Cursor backup: ${ex.message}`));
+    }
+  }
+  configManager.cursor = null;
+  configManager.save();
+};
+
+// src/commands/link-command.ts
+var LINK_MAP = {
+  ["claudecode" /* CLAUDECODE */]: linkClaudeCode,
+  ["roocode" /* ROOCODE */]: linkRooCode,
+  ["openclaw" /* OPENCLAW */]: linkOpenclaw,
+  ["codex" /* CODEX */]: linkCodex,
+  ["antigravity" /* ANTIGRAVITY */]: linkAntigravity,
+  ["cursor" /* CURSOR */]: linkCursor
+};
+var UNLINK_MAP = {
+  ["claudecode" /* CLAUDECODE */]: unlinkClaudeCode,
+  ["roocode" /* ROOCODE */]: unlinkRooCode,
+  ["openclaw" /* OPENCLAW */]: unlinkOpenclaw,
+  ["codex" /* CODEX */]: unlinkCodex,
+  ["antigravity" /* ANTIGRAVITY */]: unlinkAntigravity,
+  ["cursor" /* CURSOR */]: unlinkCursor
+};
 var linkCommand = async (tool) => {
   if (tool != null) {
     const known = ALL_AGENTS.some((a) => a.value === tool);
     if (!known) {
-      console.log(chalk4.red(`Unknown vendor: ${tool}`));
+      console.log(chalk11.red(`Unknown vendor: ${tool}`));
       process.exit(1);
     }
-    if (tool === "claudecode" /* CLAUDECODE */) {
-      await linkClaudeCode();
-    } else if (tool === "roocode" /* ROOCODE */) {
-      await linkRooCode();
-    } else if (tool === "openclaw" /* OPENCLAW */) {
-      await linkOpenclaw();
-    } else if (tool === "codex" /* CODEX */) {
-      await linkCodex();
-    } else if (tool === "antigravity" /* ANTIGRAVITY */) {
-      await linkAntigravity();
-    }
+    await LINK_MAP[tool]();
     return;
   }
   const prevLinked = {
@@ -1183,80 +1841,84 @@ var linkCommand = async (tool) => {
     ["roocode" /* ROOCODE */]: configManager.isRooCodeEnabled(),
     ["openclaw" /* OPENCLAW */]: configManager.isOpenclawEnabled(),
     ["codex" /* CODEX */]: configManager.isCodexEnabled(),
-    ["antigravity" /* ANTIGRAVITY */]: configManager.isAntigravityEnabled()
+    ["antigravity" /* ANTIGRAVITY */]: configManager.isAntigravityEnabled(),
+    ["cursor" /* CURSOR */]: configManager.isCursorEnabled()
   };
   const selected = await checkbox({
     message: "Which AI agent do you want to integrate?",
     choices: ALL_AGENTS.map((a) => ({
-      name: prevLinked[a.value] ? `${a.name} ${chalk4.dim("(applied)")}` : a.name,
+      name: prevLinked[a.value] ? `${a.name} ${chalk11.dim("(applied)")}` : a.name,
       value: a.value,
       checked: prevLinked[a.value]
     }))
   });
+  const toLink = ALL_AGENTS.filter((a) => !prevLinked[a.value] && selected.includes(a.value));
+  const toUnlink = ALL_AGENTS.filter((a) => prevLinked[a.value] && !selected.includes(a.value));
+  console.log();
+  if (toLink.length > 0) {
+    console.log(chalk11.green("  Link   ") + chalk11.dim("\u2192 ") + toLink.map((a) => chalk11.bold(a.name)).join(chalk11.dim(", ")));
+  }
+  if (toUnlink.length > 0) {
+    console.log(chalk11.red("  Unlink ") + chalk11.dim("\u2192 ") + toUnlink.map((a) => chalk11.bold(a.name)).join(chalk11.dim(", ")));
+  }
+  console.log();
+  if (toLink.length === 0 && toUnlink.length === 0) {
+    return;
+  }
   for (const a of ALL_AGENTS) {
     const was = prevLinked[a.value];
     const now = selected.includes(a.value);
     if (!was && now) {
-      if (a.value === "claudecode" /* CLAUDECODE */) {
-        await linkClaudeCode();
-      } else if (a.value === "roocode" /* ROOCODE */) {
-        await linkRooCode();
-      } else if (a.value === "openclaw" /* OPENCLAW */) {
-        await linkOpenclaw();
-      } else if (a.value === "codex" /* CODEX */) {
-        await linkCodex();
-      } else if (a.value === "antigravity" /* ANTIGRAVITY */) {
-        await linkAntigravity();
-      }
+      await LINK_MAP[a.value]();
     }
     if (was && !now) {
-      if (a.value === "claudecode" /* CLAUDECODE */) {
-        await unlinkClaudeCode(true);
-      } else if (a.value === "roocode" /* ROOCODE */) {
-        await unlinkRooCode(true);
-      } else if (a.value === "openclaw" /* OPENCLAW */) {
-        await unlinkOpenclaw(true);
-      } else if (a.value === "antigravity" /* ANTIGRAVITY */) {
-        await unlinkAntigravity(true);
-      }
+      await UNLINK_MAP[a.value](true);
     }
   }
 };
 
 // src/commands/uninstall-command.ts
-import fs5 from "fs";
-import chalk5 from "chalk";
-import { confirm as confirm4 } from "@inquirer/prompts";
+import fs10 from "fs";
+import chalk12 from "chalk";
+import { confirm as confirm9 } from "@inquirer/prompts";
 var uninstallCommand = async () => {
   const targets = [
-    { label: `Config file  ${chalk5.dim(CONFIG_PATH)}`, path: CONFIG_PATH },
-    { label: `Home dir     ${chalk5.dim(HOME_DIR)}`, path: HOME_DIR }
-  ].filter((t) => fs5.existsSync(t.path));
+    { label: `Config file  ${chalk12.dim(CONFIG_PATH)}`, path: CONFIG_PATH },
+    { label: `Home dir     ${chalk12.dim(HOME_DIR)}`, path: HOME_DIR }
+  ].filter((t) => fs10.existsSync(t.path));
   const hasClaudeCode = configManager.isClaudeCodeEnabled();
   const hasRooCode = configManager.isRooCodeEnabled();
   const hasOpenclaw = configManager.isOpenclawEnabled();
   const hasAntigravity = configManager.isAntigravityEnabled();
-  if (targets.length === 0 && !hasClaudeCode && !hasRooCode && !hasOpenclaw && !hasAntigravity) {
-    console.log(chalk5.yellow("Nothing to remove."));
+  const hasCodex = configManager.isCodexEnabled();
+  const hasCursor = configManager.isCursorEnabled();
+  if (targets.length === 0 && !hasClaudeCode && !hasRooCode && !hasOpenclaw && !hasAntigravity && !hasCodex && !hasCursor) {
+    console.log(chalk12.yellow("Nothing to remove."));
     return;
   }
-  console.log(chalk5.red("\nThe following will be removed:"));
+  console.log(chalk12.red("\nThe following will be removed:"));
   targets.forEach((t) => console.log(`  ${t.label}`));
   if (hasClaudeCode) {
-    console.log(`  Claude Code plugin dir  ${chalk5.dim(CLAUDE_CODE_DIR)}`);
+    console.log(`  Claude Code plugin dir  ${chalk12.dim(CLAUDE_CODE_DIR)}`);
   }
   if (hasRooCode) {
-    console.log(`  RooCode symlinks ${chalk5.dim("(backup will be restored)")}`);
+    console.log(`  RooCode symlinks ${chalk12.dim("(backup will be restored)")}`);
   }
   if (hasOpenclaw) {
-    console.log(`  OpenClaw symlinks ${chalk5.dim("(backup will be restored)")}`);
+    console.log(`  OpenClaw symlinks ${chalk12.dim("(backup will be restored)")}`);
   }
   if (hasAntigravity) {
-    console.log(`  Antigravity symlinks ${chalk5.dim("(backup will be restored)")}`);
+    console.log(`  Antigravity symlinks ${chalk12.dim("(backup will be restored)")}`);
+  }
+  if (hasCodex) {
+    console.log(`  Codex symlinks ${chalk12.dim("(backup will be restored)")}`);
+  }
+  if (hasCursor) {
+    console.log(`  Cursor plugin dir ${chalk12.dim("(symlink will be removed)")}`);
   }
-  const ok = await confirm4({ message: "Proceed?", default: false });
+  const ok = await confirm9({ message: "Proceed?", default: false });
   if (!ok) {
-    console.log(chalk5.yellow("Cancelled."));
+    console.log(chalk12.yellow("Cancelled."));
     return;
   }
   if (hasClaudeCode) {
@@ -1271,27 +1933,33 @@ var uninstallCommand = async () => {
   if (hasAntigravity) {
     await unlinkAntigravity(true);
   }
+  if (hasCodex) {
+    await unlinkCodex(true);
+  }
+  if (hasCursor) {
+    await unlinkCursor(true);
+  }
   for (const t of targets) {
-    fs5.rmSync(t.path, { recursive: true, force: true });
-    console.log(chalk5.dim(`  removed: ${t.path}`));
+    fs10.rmSync(t.path, { recursive: true, force: true });
+    console.log(chalk12.dim(`  removed: ${t.path}`));
   }
-  console.log(chalk5.green("\nUninstalled."));
+  console.log(chalk12.green("\nUninstalled."));
 };
 
 // src/commands/status-command.ts
-import chalk6 from "chalk";
+import chalk13 from "chalk";
 var statusCommand = () => {
   if (configManager.repo_path == null) {
-    console.log(chalk6.yellow("\u274C No repo installed."));
-    console.log(chalk6.dim(`  Run: set-prompt install <repo-url>`));
+    console.log(chalk13.yellow("\u274C No repo installed."));
+    console.log(chalk13.dim(`  Run: set-prompt install <repo-url>`));
     return;
   }
-  console.log(chalk6.bold("\nRepo"));
-  console.log(`${TAB}path   ${chalk6.cyan(configManager.repo_path)}`);
+  console.log(chalk13.bold("\nRepo"));
+  console.log(`${TAB}path   ${chalk13.cyan(configManager.repo_path)}`);
   if (configManager.remote_url != null) {
-    console.log(`${TAB}remote ${chalk6.dim(configManager.remote_url)}`);
+    console.log(`${TAB}remote ${chalk13.dim(configManager.remote_url)}`);
   }
-  console.log(chalk6.bold("\nLinked agents"));
+  console.log(chalk13.bold("\nLinked agents"));
   for (const agent of ALL_AGENTS) {
     let linked = false;
     let agentPath = null;
@@ -1311,8 +1979,8 @@ var statusCommand = () => {
       linked = configManager.isAntigravityEnabled();
       agentPath = configManager.antigravity?.path;
     }
-    const label = linked ? chalk6.green("linked") : chalk6.dim("not linked");
-    const pathStr = linked && agentPath ? chalk6.dim(` \u2192 ${agentPath}`) : "";
+    const label = linked ? chalk13.green("linked") : chalk13.dim("not linked");
+    const pathStr = linked && agentPath ? chalk13.dim(` \u2192 ${agentPath}`) : "";
     console.log(`${TAB}${agent.name.padEnd(12)} ${label}${pathStr}`);
   }
   console.log("");
@@ -1320,69 +1988,69 @@ var statusCommand = () => {
 
 // src/commands/update-command.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import chalk7 from "chalk";
+import chalk14 from "chalk";
 var updateCommand = () => {
   const repoPath = configManager.repo_path;
   if (repoPath == null) {
-    console.error(chalk7.red("\u274C No repo installed."));
-    console.log(chalk7.yellow("Run: set-prompt install <git-url>"));
+    console.error(chalk14.red("\u274C No repo installed."));
+    console.log(chalk14.yellow("Run: set-prompt install <git-url>"));
     return;
   }
   if (configManager.remote_url == null) {
-    console.error(chalk7.red("\u274C No remote URL registered. Cannot update."));
+    console.error(chalk14.red("\u274C No remote URL registered. Cannot update."));
     return;
   }
-  console.log(chalk7.green("\nUpdating prompt repo..."));
-  console.log(chalk7.dim(repoPath));
+  console.log(chalk14.green("\nUpdating prompt repo..."));
+  console.log(chalk14.dim(repoPath));
   const fetch = spawnSync2("git", ["fetch"], { cwd: repoPath, stdio: "inherit" });
   if (fetch.status !== 0) {
-    console.error(chalk7.red("\u274C git fetch failed."));
+    console.error(chalk14.red("\u274C git fetch failed."));
     return;
   }
   const pull = spawnSync2("git", ["pull"], { cwd: repoPath, stdio: "inherit" });
   if (pull.status !== 0) {
-    console.error(chalk7.red("\u274C git pull failed."));
+    console.error(chalk14.red("\u274C git pull failed."));
     return;
   }
-  console.log(chalk7.green("\u2705 Repo updated."));
+  console.log(chalk14.green("\u2705 Repo updated."));
 };
 
 // src/index.ts
 process.on("SIGINT", () => {
-  console.log(chalk8.yellow("\nCancelled."));
+  console.log(chalk15.yellow("\nCancelled."));
   process.exit(0);
 });
 process.on("unhandledRejection", (reason) => {
   if (reason instanceof Error && reason.name === "ExitPromptError") {
-    console.log(chalk8.yellow("\nCancelled."));
+    console.log(chalk15.yellow("\nCancelled."));
     process.exit(0);
   }
   throw reason;
 });
-var __dirname = path5.dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(fs6.readFileSync(path5.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path10.dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(fs11.readFileSync(path10.join(__dirname, "../package.json"), "utf-8"));
 configManager.init();
 var program = new Command();
-var banner = chalk8.cyan(figlet.textSync("Set-Prompt", { horizontalLayout: "full" }));
+var banner = chalk15.cyan(figlet.textSync("Set-Prompt", { horizontalLayout: "full" }));
 program.name("set-prompt").description(pkg.description).version(pkg.version).addHelpText("beforeAll", banner + "\n").action(() => {
   program.help();
 });
-program.command("install").description(`\u{1F4E6} Clone a ${chalk8.cyan("git repo")} into ${chalk8.dim("~/.set-prompt/repo/")} and register it as your prompt source`).argument("<url>", "remote git URL").action(async (source) => {
+program.command("install").description(`\u{1F4E6} Clone a ${chalk15.cyan("git repo")} into ${chalk15.dim("~/.set-prompt/repo/")} and register it as your prompt source`).argument("<url>", "remote git URL").action(async (source) => {
   await installCommand(source);
 });
-program.command("link").description(`\u{1F517} Symlink your prompt repo into an ${chalk8.cyan("AI agent")} plugin dir ${chalk8.dim("(claudecode | roocode | openclaw | codex | antigravity)")}`).argument("[agent]", `target agent ${chalk8.dim("(omit for interactive selection)")}`).action(async (agent) => {
+program.command("link").description(`\u{1F517} Symlink your prompt repo into an ${chalk15.cyan("AI agent")} plugin dir ${chalk15.dim("(claudecode | roocode | openclaw | codex | antigravity)")}`).argument("[agent]", `target agent ${chalk15.dim("(omit for interactive selection)")}`).action(async (agent) => {
   await linkCommand(agent);
 });
-program.command("scaffold").description(`\u{1F6E0}\uFE0F  Verify and create ${chalk8.cyan("required directories")} in a prompt repo ${chalk8.dim("(-f to force overwrite)")}`).argument("[path]", `path to repo ${chalk8.dim("(defaults to installed source)")}`).option("-f, --force", "overwrite existing files without prompting").action(async (localPath, options) => {
-  await scaffoldCommand(localPath, options);
+program.command("scaffold").description(`\u{1F6E0}\uFE0F  Verify and create ${chalk15.cyan("required directories")} in a prompt repo ${chalk15.dim("(-f to force overwrite)")}`).argument("[path]", `path to repo ${chalk15.dim("(defaults to installed source)")}`).action(async (localPath) => {
+  await scaffoldCommand(localPath);
 });
-program.command("status").description(`\u{1F4CB} Show registered ${chalk8.cyan("repo")} and which ${chalk8.cyan("agents")} are linked`).action(() => {
+program.command("status").description(`\u{1F4CB} Show registered ${chalk15.cyan("repo")} and which ${chalk15.cyan("agents")} are linked`).action(() => {
   statusCommand();
 });
-program.command("update").description(`\u{1F504} Fetch and pull the latest changes from the ${chalk8.cyan("remote repo")}`).action(() => {
+program.command("update").description(`\u{1F504} Fetch and pull the latest changes from the ${chalk15.cyan("remote repo")}`).action(() => {
   updateCommand();
 });
-program.command("uninstall").description(`\u{1F5D1}\uFE0F  Remove all set-prompt data ${chalk8.dim("(~/.set-prompt/, plugin dirs, settings entries)")}`).action(async () => {
+program.command("uninstall").description(`\u{1F5D1}\uFE0F  Remove all set-prompt data ${chalk15.dim("(~/.set-prompt/, plugin dirs, settings entries)")}`).action(async () => {
   await uninstallCommand();
 });
 program.parse(process.argv);