set-prompt 0.5.3 → 0.6.0

package/dist/index.js

@@ -2,17 +2,17 @@
 
 // src/index.ts
 import { Command } from "commander";
-import chalk15 from "chalk";
+import chalk21 from "chalk";
 import figlet from "figlet";
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/install-command.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import path3 from "path";
-import { spawnSync } from "child_process";
-import chalk4 from "chalk";
+import { spawnSync as spawnSync3 } from "child_process";
+import chalk5 from "chalk";
 import { confirm as confirm2 } from "@inquirer/prompts";
 
 // src/_defs/index.ts
@@ -239,6 +239,8 @@ var ConfigManager = class {
 var configManager = new ConfigManager();
 
 // src/_libs/index.ts
+import { spawnSync } from "child_process";
+import fs2 from "fs";
 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 = () => {
@@ -249,11 +251,71 @@ var resolveRepoPath = () => {
   }
   return configManager.repo_path;
 };
+var isOnPath = (bin) => {
+  const probeCmd = process.platform === "win32" ? "where" : "which";
+  const probe = spawnSync(probeCmd, [bin], { stdio: "ignore" });
+  return probe.status === 0;
+};
+var firstExistingPath = (candidates) => {
+  for (const candidate of candidates) {
+    if (candidate != null && candidate !== "" && fs2.existsSync(candidate)) return candidate;
+  }
+  return null;
+};
+
+// src/_libs/repo.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import chalk3 from "chalk";
+var parsePorcelainLine = (line) => {
+  if (line.length < 4) return null;
+  const status = line.slice(0, 2);
+  let name = line.slice(3);
+  const arrowIdx = name.indexOf(" -> ");
+  if (arrowIdx >= 0) name = name.slice(arrowIdx + 4);
+  if (name.startsWith('"') && name.endsWith('"')) name = name.slice(1, -1);
+  if (status.includes("?")) return { kind: "?", name };
+  if (status.includes("D")) return { kind: "D", name };
+  if (status.includes("R")) return { kind: "R", name };
+  if (status.includes("A")) return { kind: "A", name };
+  if (status.includes("M")) return { kind: "M", name };
+  return null;
+};
+var pickVerb = (files) => {
+  const allAdded = files.every((f) => f.kind === "A" || f.kind === "?");
+  const allDeleted = files.every((f) => f.kind === "D");
+  if (allAdded) return "add";
+  if (allDeleted) return "remove";
+  return "update";
+};
+var generateCommitMessage = (repoPath) => {
+  const result = spawnSync2("git", ["status", "--porcelain", "--untracked-files=all"], {
+    cwd: repoPath,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) return null;
+  const files = result.stdout.split("\n").map(parsePorcelainLine).filter((f) => f !== null);
+  if (files.length === 0) return null;
+  const verb = pickVerb(files);
+  const noun = files.length === 1 ? "file" : "files";
+  const subject = `${verb} ${files.length} ${noun}`;
+  const body = files.map((f) => `- ${f.name}`).join("\n");
+  return `${subject}
+
+${body}`;
+};
+var printSaveHint = (repoPath) => {
+  const generated = generateCommitMessage(repoPath);
+  if (generated == null) return;
+  const subject = generated.split("\n")[0];
+  console.log(chalk3.yellow("\nUncommitted changes detected."));
+  console.log(chalk3.dim(`  Pending: ${subject}`));
+  console.log(chalk3.cyan("  Tip: run `sppt repo save` to commit and push."));
+};
 
 // src/commands/scaffold-command.ts
-import fs2 from "fs";
+import fs3 from "fs";
 import path2 from "path";
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { confirm } from "@inquirer/prompts";
 
 // src/_libs/templates.ts
@@ -278,9 +340,15 @@ This is a shared prompt repository linked to various AI agents via \`set-prompt
 \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
+\u251C\u2500\u2500 rules/                 # Rule definitions (Cursor)
+\u2502   \u2514\u2500\u2500 <rule-name>/
+\u2502       \u2514\u2500\u2500 RULE.md
+\u251C\u2500\u2500 .mcp.json              # MCP server configurations
+\u251C\u2500\u2500 .app.json              # Application configurations
+\u251C\u2500\u2500 .claude-plugin/
+\u2502   \u2514\u2500\u2500 plugin.json        # Claude Code plugin manifest
+\u2514\u2500\u2500 .codex-plugin/
+    \u2514\u2500\u2500 plugin.json        # Codex plugin manifest
 \`\`\`
 
 ## Usage
@@ -293,8 +361,23 @@ set-prompt scaffold .
 set-prompt install https://github.com/you/my-prompts
 set-prompt link
 
-# Pull latest changes
-set-prompt update
+# Inspect current state (branch, ahead/behind, changed files)
+set-prompt repo status
+
+# Pull latest changes from remote
+set-prompt repo pull
+
+# Commit + push local edits in one step (auto-generates message if -m omitted)
+set-prompt repo save -m "update skills"
+set-prompt repo save
+
+# Or commit and push separately
+set-prompt repo commit -m "update skills"
+set-prompt repo push
+
+# Jump into the repo or open it in an editor
+cd "$(set-prompt repo path)"
+set-prompt repo open --code
 \`\`\`
 
 ## Frontmatter Reference
@@ -644,43 +727,86 @@ echo '{"permission":"deny","user_message":"Blocked by policy","agent_message":"N
 `;
 
 // src/commands/scaffold-command.ts
+var validateClaudePluginManifest = (data) => {
+  const issues = [];
+  if (typeof data !== "object" || data === null) return ["root must be a JSON object"];
+  const obj = data;
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    issues.push('"name" is required and must be a non-empty string');
+  }
+  return issues;
+};
+var validateCodexPluginManifest = (data) => {
+  const issues = [];
+  if (typeof data !== "object" || data === null) return ["root must be a JSON object"];
+  const obj = data;
+  if (typeof obj.name !== "string" || obj.name.length === 0) {
+    issues.push('"name" is required and must be a non-empty string');
+  }
+  if (typeof obj.skills !== "string" || obj.skills.length === 0) {
+    issues.push('"skills" is required and must be a string path (e.g. "./skills/")');
+  }
+  if (typeof obj.mcpServers !== "string" || obj.mcpServers.length === 0) {
+    issues.push('"mcpServers" is required and must be a string path (e.g. "./.mcp.json")');
+  }
+  if (typeof obj.apps !== "string" || obj.apps.length === 0) {
+    issues.push('"apps" is required and must be a string path (e.g. "./.app.json")');
+  }
+  return issues;
+};
+var ensureManifest = (jsonPath, metaDir, validate, defaultData, label) => {
+  if (fs3.existsSync(jsonPath)) {
+    try {
+      const parsed = JSON.parse(fs3.readFileSync(jsonPath, "utf-8"));
+      const issues = validate(parsed);
+      if (issues.length === 0) return "valid";
+      console.warn(chalk4.yellow(`  \u26A0 ${label} has issues \u2014 keeping existing file:`));
+      for (const issue of issues) console.warn(chalk4.dim(`     ${issue}`));
+      return "invalid";
+    } catch (ex) {
+      console.warn(chalk4.yellow(`  \u26A0 ${label} failed to parse: ${ex.message} \u2014 keeping existing file`));
+      return "invalid";
+    }
+  }
+  fs3.mkdirSync(metaDir, { recursive: true });
+  fs3.writeFileSync(jsonPath, JSON.stringify(defaultData, null, 4), { encoding: "utf-8" });
+  return "created";
+};
 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({
+  return ensureManifest(jsonPath, metaDir, validateClaudePluginManifest, {
     name: PLUGIN_NAME,
     version: "1.0.0",
-    description: `Managed by set-prompt \u2014 ${repoPath}`
-  }, null, 4), { encoding: "utf-8" });
+    description: "Managed by set-prompt"
+  }, ".claude-plugin/plugin.json");
 };
 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({
+  return ensureManifest(jsonPath, metaDir, validateCodexPluginManifest, {
     name: PLUGIN_NAME,
     version: "1.0.0",
-    description: `Managed by set-prompt \u2014 ${repoPath}`,
+    description: "Managed by set-prompt",
     skills: "./skills/",
     mcpServers: "./.mcp.json",
     apps: "./.app.json"
-  }, null, 4), { encoding: "utf-8" });
+  }, ".codex-plugin/plugin.json");
 };
 var ensureMcpJson = (repoPath) => {
   const mcpJsonPath = path2.join(repoPath, ".mcp.json");
-  if (fs2.existsSync(mcpJsonPath)) {
+  if (fs3.existsSync(mcpJsonPath)) {
     return false;
   }
-  fs2.writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: {} }, null, 4), { encoding: "utf-8" });
+  fs3.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)) {
+  if (fs3.existsSync(appJsonPath)) {
     return false;
   }
-  fs2.writeFileSync(appJsonPath, JSON.stringify({ apps: {} }, null, 4), { encoding: "utf-8" });
+  fs3.writeFileSync(appJsonPath, JSON.stringify({ apps: {} }, null, 4), { encoding: "utf-8" });
   return true;
 };
 var scaffoldCommand = async (localPath) => {
@@ -692,15 +818,15 @@ var scaffoldCommand = async (localPath) => {
       if (configManager.repo_path != null) {
         targetPath = configManager.repo_path;
       } else {
-        console.error(chalk3.red("No path provided and no repo registered. Please provide a path."));
+        console.error(chalk4.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(chalk3.red(`Invalid directory path: '${targetPath}'`));
+    if (fs3.existsSync(targetPath) === false || fs3.statSync(targetPath).isDirectory() === false) {
+      console.error(chalk4.red(`Invalid directory path: '${targetPath}'`));
       process.exit(1);
     }
-    console.log(chalk3.dim(`Scaffolding: ${targetPath}
+    console.log(chalk4.dim(`Scaffolding: ${targetPath}
 `));
     const writeGuide = await confirm({
       message: "Generate SET_PROMPT_GUIDE.md? (reference doc for writing prompts)",
@@ -708,32 +834,36 @@ var scaffoldCommand = async (localPath) => {
     });
     if (writeGuide) {
       const guideMdPath = path2.join(targetPath, "SET_PROMPT_GUIDE.md");
-      fs2.writeFileSync(guideMdPath, SET_PROMPT_GUIDE, { encoding: "utf-8", flag: "w" });
-      console.log(`${TAB}${chalk3.green("\u2713")} SET_PROMPT_GUIDE.md`);
+      fs3.writeFileSync(guideMdPath, SET_PROMPT_GUIDE, { encoding: "utf-8", flag: "w" });
+      console.log(`${TAB}${chalk4.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}/`);
+      if (fs3.existsSync(dirPath)) {
+        console.log(`${TAB}${chalk4.dim("\u2713")} ${dirName}/`);
       } else {
-        fs2.mkdirSync(dirPath, { recursive: true });
-        console.log(`${TAB}${chalk3.green("+")} ${dirName}/`);
+        fs3.mkdirSync(dirPath, { recursive: true });
+        console.log(`${TAB}${chalk4.green("+")} ${dirName}/`);
       }
       const gitkeepPath = path2.join(dirPath, ".gitkeep");
-      if (!fs2.existsSync(gitkeepPath)) {
-        fs2.writeFileSync(gitkeepPath, "", { encoding: "utf-8" });
+      if (!fs3.existsSync(gitkeepPath)) {
+        fs3.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."));
+    const symFor = (r) => r === "created" ? chalk4.green("+") : r === "valid" ? chalk4.dim("\u2713") : chalk4.yellow("\u26A0");
+    const claudeResult = ensureClaudePluginManifest(targetPath);
+    console.log(`${TAB}${symFor(claudeResult)} .claude-plugin/plugin.json`);
+    const codexResult = ensureCodexPluginManifest(targetPath);
+    console.log(`${TAB}${symFor(codexResult)} .codex-plugin/plugin.json`);
+    console.log(`${TAB}${ensureMcpJson(targetPath) ? chalk4.green("+") : chalk4.dim("\u2713")} .mcp.json`);
+    console.log(`${TAB}${ensureAppJson(targetPath) ? chalk4.green("+") : chalk4.dim("\u2713")} .app.json`);
+    console.log(chalk4.green("\nScaffold complete."));
+    if (configManager.repo_path != null && path2.resolve(targetPath) === path2.resolve(configManager.repo_path)) {
+      printSaveHint(targetPath);
+    }
     return true;
   } catch (ex) {
-    console.error(chalk3.red(`Failed to scaffold repo structure: ${ex.message}`), ex);
+    console.error(chalk4.red(`Failed to scaffold repo structure: ${ex.message}`), ex);
     throw ex;
   }
 };
@@ -742,86 +872,87 @@ var scaffoldCommand = async (localPath) => {
 var cloneRepo = async (remoteUrl) => {
   const localPath = path3.join(HOME_DIR, "repo");
   let backupPath = null;
-  if (fs3.existsSync(localPath) == true) {
+  if (fs4.existsSync(localPath) == true) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     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}`));
+      fs4.renameSync(localPath, backupPath);
+      console.log(chalk5.yellow("  backed up") + chalk5.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}`));
+        console.error(chalk5.red("\u274C Cannot rename existing repo \u2014 it may be open in another process."));
+        console.log(chalk5.dim(`   Close any editors or terminals using: ${localPath}`));
       } else {
-        console.error(chalk4.red(`\u274C Failed to backup existing repo: ${ex.message}`));
+        console.error(chalk5.red(`\u274C Failed to backup existing repo: ${ex.message}`));
       }
       return false;
     }
   }
-  fs3.mkdirSync(path3.dirname(localPath), { recursive: true });
+  fs4.mkdirSync(path3.dirname(localPath), { recursive: true });
   console.log(`Cloning ${remoteUrl}...`);
-  const result = spawnSync("git", ["clone", remoteUrl, localPath], { stdio: "inherit" });
+  const result = spawnSync3("git", ["clone", remoteUrl, localPath], { stdio: "inherit" });
   if (result.status !== 0) {
     console.log("\u274C Failed to clone. Check the URL and your git credentials.");
     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}`));
+    fs4.rmSync(backupPath, { recursive: true, force: true });
+    console.log(chalk5.red("  removed") + chalk5.dim(` backup \u2192 ${backupPath}`));
   }
-  await scaffoldCommand(localPath, { force: true });
+  await scaffoldCommand(localPath);
   configManager.repo_path = localPath;
   configManager.remote_url = remoteUrl;
   if (configManager.save() === false) {
-    console.error(chalk4.red("Failed to save config."));
+    console.error(chalk5.red("Failed to save config."));
     return false;
   }
+  printSaveHint(localPath);
   return true;
 };
 var installCommand = async (target) => {
   try {
     if (isGitUrl(target) === false) {
-      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"));
+      console.error(chalk5.red("\u274C Only remote git URLs are supported."));
+      console.log(chalk5.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."));
+        console.error(chalk5.red(`\u274C Already installed from the same URL: ${target}`));
+        console.log(chalk5.dim("   Use `set-prompt repo pull` to pull the latest changes."));
         return false;
       }
-      console.warn(chalk4.yellow(`\u26A0 Switching repo: ${configManager.remote_url} \u2192 ${target}`));
+      console.warn(chalk5.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."));
+        console.log(chalk5.yellow("Cancelled."));
         return false;
       }
     } else {
       const proceed = await confirm2({ message: `Clone and register "${target}"?`, default: true });
       if (!proceed) {
-        console.log(chalk4.yellow("Cancelled."));
+        console.log(chalk5.yellow("Cancelled."));
         return false;
       }
     }
     return await cloneRepo(target);
   } catch (ex) {
-    console.error(chalk4.red(`Unexpected error: ${ex.message}`), ex);
+    console.error(chalk5.red(`Unexpected error: ${ex.message}`), ex);
     process.exit(1);
   }
 };
 
 // src/commands/link-command.ts
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import { checkbox } from "@inquirer/prompts";
 
 // src/link/claudecode.ts
 import path4 from "path";
-import fs4 from "fs";
+import fs5 from "fs";
 import os2 from "os";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import { confirm as confirm3 } from "@inquirer/prompts";
 var linkClaudeCode = async () => {
   const repoPath = resolveRepoPath();
@@ -831,32 +962,32 @@ var linkClaudeCode = async () => {
   const buildMarketplace = () => {
     try {
       const marketplaceMetaDir = path4.join(CLAUDE_CODE_DIR, ".claude-plugin");
-      fs4.mkdirSync(marketplaceMetaDir, { recursive: true });
+      fs5.mkdirSync(marketplaceMetaDir, { recursive: true });
       const marketplaceJson = {
         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(
+      fs5.writeFileSync(
         path4.join(marketplaceMetaDir, "marketplace.json"),
         JSON.stringify(marketplaceJson, null, 4),
         "utf-8"
       );
-      console.log(chalk5.dim("  \u251C\u2500\u2500 .claude-plugin/"));
-      console.log(chalk5.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk5.green(" \u2713"));
+      console.log(chalk6.dim("  \u251C\u2500\u2500 .claude-plugin/"));
+      console.log(chalk6.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk6.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 });
+      fs5.mkdirSync(path4.dirname(pluginLink), { recursive: true });
+      if (fs5.existsSync(pluginLink)) {
+        fs5.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"));
+      fs5.symlinkSync(repoPath, pluginLink, symlinkType);
+      console.log(chalk6.dim("  \u2514\u2500\u2500 plugins/"));
+      console.log(chalk6.dim(`      \u2514\u2500\u2500 ${PLUGIN_NAME}/`) + chalk6.dim(` \u2192 ${repoPath}`) + chalk6.green(" \u2713"));
       return true;
     } catch (ex) {
-      console.error(chalk5.red(`\u274C Failed to build marketplace structure: ${ex.message}`));
+      console.error(chalk6.red(`\u274C Failed to build marketplace structure: ${ex.message}`));
       return false;
     }
   };
@@ -864,18 +995,18 @@ var linkClaudeCode = async () => {
     const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
     try {
       let settings = {};
-      if (fs4.existsSync(claudeSettingsPath)) {
-        const raw = fs4.readFileSync(claudeSettingsPath, "utf-8");
+      if (fs5.existsSync(claudeSettingsPath)) {
+        const raw = fs5.readFileSync(claudeSettingsPath, "utf-8");
         try {
           const parsed = JSON.parse(raw);
           if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
             settings = parsed;
           } else {
-            console.warn(chalk5.yellow("  \u26A0 settings.json has unexpected format \u2014 proceeding with caution"));
+            console.warn(chalk6.yellow("  \u26A0 settings.json has unexpected format \u2014 proceeding with caution"));
           }
         } catch {
-          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."));
+          console.warn(chalk6.yellow("  \u26A0 Failed to parse settings.json \u2014 will not overwrite existing file"));
+          console.error(chalk6.red("\u274C Could not register plugin. Please add manually."));
           return false;
         }
       }
@@ -888,43 +1019,43 @@ var linkClaudeCode = async () => {
         [`${PLUGIN_NAME}@${MARKET_NAME}`]: true
       };
       let backupPath = null;
-      if (fs4.existsSync(claudeSettingsPath)) {
+      if (fs5.existsSync(claudeSettingsPath)) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
         try {
-          fs4.copyFileSync(claudeSettingsPath, backupPath);
+          fs5.copyFileSync(claudeSettingsPath, backupPath);
         } catch (ex) {
-          console.warn(chalk5.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
+          console.warn(chalk6.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, 4), "utf-8");
+        fs5.mkdirSync(path4.dirname(claudeSettingsPath), { recursive: true });
+        fs5.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
       } catch (ex) {
         if (backupPath !== null) {
           try {
-            fs4.copyFileSync(backupPath, claudeSettingsPath);
-            fs4.unlinkSync(backupPath);
-            console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+            fs5.copyFileSync(backupPath, claudeSettingsPath);
+            fs5.unlinkSync(backupPath);
+            console.warn(chalk6.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
           } catch {
-            console.error(chalk5.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+            console.error(chalk6.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
           }
         }
         throw ex;
       }
       if (backupPath !== null) {
         try {
-          fs4.unlinkSync(backupPath);
+          fs5.unlinkSync(backupPath);
         } catch {
         }
       }
       console.log(`\u2705 Registered to Claude Code settings.`);
-      console.log(chalk5.dim(`   ${claudeSettingsPath}`));
+      console.log(chalk6.dim(`   ${claudeSettingsPath}`));
       return true;
     } catch (ex) {
-      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."));
+      console.error(chalk6.red(`\u274C Failed to update settings.json: ${ex.message}`));
+      console.log(chalk6.dim("   Please add the plugin manually via Claude Code /plugins."));
       return false;
     }
   };
@@ -934,9 +1065,9 @@ var linkClaudeCode = async () => {
     const pluginKey = `${PLUGIN_NAME}@${MARKET_NAME}`;
     try {
       let data = { version: 2, plugins: {} };
-      if (fs4.existsSync(installedPluginsPath)) {
+      if (fs5.existsSync(installedPluginsPath)) {
         try {
-          data = JSON.parse(fs4.readFileSync(installedPluginsPath, "utf-8"));
+          data = JSON.parse(fs5.readFileSync(installedPluginsPath, "utf-8"));
         } catch {
         }
       }
@@ -952,17 +1083,17 @@ var linkClaudeCode = async () => {
           lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
         }
       ];
-      fs4.mkdirSync(path4.dirname(installedPluginsPath), { recursive: true });
-      fs4.writeFileSync(installedPluginsPath, JSON.stringify(data, null, 4), "utf-8");
+      fs5.mkdirSync(path4.dirname(installedPluginsPath), { recursive: true });
+      fs5.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}`));
+      console.log(chalk6.dim(`   ${installPath}`));
     } catch (ex) {
-      console.warn(chalk5.yellow(`  \u26A0 Could not patch installed_plugins.json: ${ex.message}`));
+      console.warn(chalk6.yellow(`  \u26A0 Could not patch installed_plugins.json: ${ex.message}`));
     }
   };
-  console.log(chalk5.green(`
+  console.log(chalk6.green(`
 Setting up Claude Code plugin...`));
-  console.log(chalk5.dim(CLAUDE_CODE_DIR));
+  console.log(chalk6.dim(CLAUDE_CODE_DIR));
   const marketplaceOk = buildMarketplace();
   if (marketplaceOk === false) {
     return;
@@ -982,20 +1113,20 @@ var unlinkClaudeCode = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk5.yellow("Cancelled."));
+      console.log(chalk6.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk5.red(`
+  console.log(chalk6.red(`
 Removing Claude Code plugin...`));
-  console.log(chalk5.dim(CLAUDE_CODE_DIR));
+  console.log(chalk6.dim(CLAUDE_CODE_DIR));
   const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
-  if (fs4.existsSync(claudeSettingsPath)) {
+  if (fs5.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"));
+      fs5.copyFileSync(claudeSettingsPath, backupPath);
+      const settings = JSON.parse(fs5.readFileSync(claudeSettingsPath, "utf-8"));
       if (settings?.extraKnownMarketplaces?.[MARKET_NAME] !== void 0) {
         delete settings.extraKnownMarketplaces[MARKET_NAME];
       }
@@ -1003,26 +1134,26 @@ Removing Claude Code plugin...`));
         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}`));
+        fs5.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 4), "utf-8");
+        fs5.unlinkSync(backupPath);
+        console.log(chalk6.red("  removed") + chalk6.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."));
+        fs5.copyFileSync(backupPath, claudeSettingsPath);
+        fs5.unlinkSync(backupPath);
+        console.warn(chalk6.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
       }
     } catch (ex) {
-      console.error(chalk5.red(`  \u274C Failed to clean up settings.json: ${ex.message}`));
+      console.error(chalk6.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)) {
+  if (fs5.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"));
+      fs5.copyFileSync(installedPluginsPath, backupPath);
+      const installed = JSON.parse(fs5.readFileSync(installedPluginsPath, "utf-8"));
       if (installed?.plugins && typeof installed.plugins === "object") {
         for (const key of Object.keys(installed.plugins)) {
           if (key.endsWith(`@${MARKET_NAME}`)) {
@@ -1031,44 +1162,44 @@ Removing Claude Code plugin...`));
         }
       }
       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}`));
+        fs5.writeFileSync(installedPluginsPath, JSON.stringify(installed, null, 4), "utf-8");
+        fs5.unlinkSync(backupPath);
+        console.log(chalk6.red("  removed") + chalk6.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."));
+        fs5.copyFileSync(backupPath, installedPluginsPath);
+        fs5.unlinkSync(backupPath);
+        console.warn(chalk6.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}`));
+      console.error(chalk6.red(`  \u274C Failed to clean up installed_plugins.json: ${ex.message}`));
     }
   }
   const knownMarketplacesPath = path4.join(claudePluginsDir, "known_marketplaces.json");
-  if (fs4.existsSync(knownMarketplacesPath)) {
+  if (fs5.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"));
+      fs5.copyFileSync(knownMarketplacesPath, backupPath);
+      const marketplaces = JSON.parse(fs5.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}`));
+        fs5.writeFileSync(knownMarketplacesPath, JSON.stringify(marketplaces, null, 4), "utf-8");
+        fs5.unlinkSync(backupPath);
+        console.log(chalk6.red("  removed") + chalk6.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."));
+        fs5.copyFileSync(backupPath, knownMarketplacesPath);
+        fs5.unlinkSync(backupPath);
+        console.warn(chalk6.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}`));
+      console.error(chalk6.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}`));
+  if (fs5.existsSync(CLAUDE_CODE_DIR)) {
+    fs5.rmSync(CLAUDE_CODE_DIR, { recursive: true, force: true });
+    console.log(chalk6.red("  removed") + chalk6.dim(`: ${CLAUDE_CODE_DIR}`));
   }
   configManager.claude_code = null;
   configManager.save();
@@ -1076,8 +1207,8 @@ Removing Claude Code plugin...`));
 
 // src/link/roocode.ts
 import path5 from "path";
-import fs5 from "fs";
-import chalk6 from "chalk";
+import fs6 from "fs";
+import chalk7 from "chalk";
 import { confirm as confirm4 } from "@inquirer/prompts";
 import { pathExists } from "fs-extra";
 var linkRooCode = async () => {
@@ -1085,44 +1216,44 @@ var linkRooCode = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk6.green(`
+  console.log(chalk7.green(`
 Setting up RooCode integration...`));
-  console.log(chalk6.dim(ROO_DIR));
+  console.log(chalk7.dim(ROO_DIR));
   const roocodeDirs = AGENT_PROMPT_DIRS["roocode" /* ROOCODE */];
   const backupExistingRooCodeFiles = async () => {
     try {
-      fs5.mkdirSync(ROO_DIR, { recursive: true });
+      fs6.mkdirSync(ROO_DIR, { recursive: true });
       const dirsToBackup = [];
       for (const dir of roocodeDirs) {
         const target = path5.join(ROO_DIR, dir);
-        if (fs5.existsSync(target) && fs5.lstatSync(target).isSymbolicLink() === false && fs5.readdirSync(target).length > 0) {
+        if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink() === false && fs6.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
-      console.log(chalk6.yellow(`
+      console.log(chalk7.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(chalk7.dim(`    - ${path5.join(ROO_DIR, dir)}`));
       }
-      console.log(chalk6.yellow(`  They will be backed up to: `) + chalk6.dim(ROO_BACKUP_DIR));
+      console.log(chalk7.yellow(`  They will be backed up to: `) + chalk7.dim(ROO_BACKUP_DIR));
       const ok = await confirm4({ message: "Back up existing directories?", default: true });
       if (!ok) {
-        console.log(chalk6.yellow("Skipped RooCode linking."));
+        console.log(chalk7.yellow("Skipped RooCode linking."));
         return false;
       }
-      fs5.mkdirSync(ROO_BACKUP_DIR, { recursive: true });
+      fs6.mkdirSync(ROO_BACKUP_DIR, { recursive: true });
       for (const dir of dirsToBackup) {
         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}`));
+        fs6.renameSync(src, dest);
+        console.log(chalk7.yellow("  backed up") + chalk7.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk6.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk7.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -1135,21 +1266,21 @@ Setting up RooCode integration...`));
         if (await pathExists(src) === false) {
           continue;
         }
-        if (fs5.existsSync(dest)) {
-          fs5.rmSync(dest, { recursive: true, force: true });
+        if (fs6.existsSync(dest)) {
+          fs6.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs5.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(chalk6.dim(`  ${branch} `) + chalk6.bold(`${dir}/`) + chalk6.dim(` \u2192 ${src}`) + chalk6.green(" \u2713"));
+        console.log(chalk7.dim(`  ${branch} `) + chalk7.bold(`${dir}/`) + chalk7.dim(` \u2192 ${src}`) + chalk7.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk6.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk7.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -1171,35 +1302,35 @@ var unlinkRooCode = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk6.yellow("Cancelled."));
+      console.log(chalk7.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk6.red(`
+  console.log(chalk7.red(`
 Removing RooCode integration...`));
-  console.log(chalk6.dim(ROO_DIR));
+  console.log(chalk7.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 (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink()) {
+      fs6.unlinkSync(target);
+      console.log(chalk7.red("  removed symlink") + chalk7.dim(`: ${target}`));
     }
   }
-  if (fs5.existsSync(backupPath)) {
+  if (fs6.existsSync(backupPath)) {
     try {
       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)) {
+        if (!fs6.existsSync(src)) {
           continue;
         }
-        fs5.renameSync(src, dest);
-        console.log(chalk6.green("  restored") + chalk6.dim(`: ${dir}/`));
+        fs6.renameSync(src, dest);
+        console.log(chalk7.green("  restored") + chalk7.dim(`: ${dir}/`));
       }
-      fs5.rmdirSync(backupPath);
+      fs6.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk6.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
+      console.error(chalk7.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
     }
   }
   configManager.roocode = null;
@@ -1208,8 +1339,8 @@ Removing RooCode integration...`));
 
 // src/link/openclaw.ts
 import path6 from "path";
-import fs6 from "fs";
-import chalk7 from "chalk";
+import fs7 from "fs";
+import chalk8 from "chalk";
 import { confirm as confirm5 } from "@inquirer/prompts";
 import { pathExists as pathExists2 } from "fs-extra";
 var linkOpenclaw = async () => {
@@ -1217,44 +1348,44 @@ var linkOpenclaw = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk7.green(`
+  console.log(chalk8.green(`
 Setting up OpenClaw integration...`));
-  console.log(chalk7.dim(OPENCLAW_DIR));
+  console.log(chalk8.dim(OPENCLAW_DIR));
   const openclawDirs = AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */];
   const backupExistingOpenclawFiles = async () => {
     try {
-      fs6.mkdirSync(OPENCLAW_DIR, { recursive: true });
+      fs7.mkdirSync(OPENCLAW_DIR, { recursive: true });
       const dirsToBackup = [];
       for (const dir of openclawDirs) {
         const target = path6.join(OPENCLAW_DIR, dir);
-        if (fs6.existsSync(target) && fs6.lstatSync(target).isSymbolicLink() === false && fs6.readdirSync(target).length > 0) {
+        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(chalk7.yellow(`
+      console.log(chalk8.yellow(`
   \u26A0 The following existing directories will be replaced by symlinks:`));
       for (const dir of dirsToBackup) {
-        console.log(chalk7.dim(`    - ${path6.join(OPENCLAW_DIR, dir)}`));
+        console.log(chalk8.dim(`    - ${path6.join(OPENCLAW_DIR, dir)}`));
       }
-      console.log(chalk7.yellow(`  They will be backed up to: `) + chalk7.dim(OPENCLAW_BACKUP_DIR));
+      console.log(chalk8.yellow(`  They will be backed up to: `) + chalk8.dim(OPENCLAW_BACKUP_DIR));
       const ok = await confirm5({ message: "Back up existing directories?", default: true });
       if (!ok) {
-        console.log(chalk7.yellow("Skipped OpenClaw linking."));
+        console.log(chalk8.yellow("Skipped OpenClaw linking."));
         return false;
       }
-      fs6.mkdirSync(OPENCLAW_BACKUP_DIR, { recursive: true });
+      fs7.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}`));
+        fs7.renameSync(src, dest);
+        console.log(chalk8.yellow("  backed up") + chalk8.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk7.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk8.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -1267,21 +1398,21 @@ Setting up OpenClaw integration...`));
         if (await pathExists2(src) === false) {
           continue;
         }
-        if (fs6.existsSync(dest)) {
-          fs6.rmSync(dest, { recursive: true, force: true });
+        if (fs7.existsSync(dest)) {
+          fs7.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs6.symlinkSync(src, dest, symlinkType);
+        fs7.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(chalk7.dim(`  ${branch} `) + chalk7.bold(`${dir}/`) + chalk7.dim(` \u2192 ${src}`) + chalk7.green(" \u2713"));
+        console.log(chalk8.dim(`  ${branch} `) + chalk8.bold(`${dir}/`) + chalk8.dim(` \u2192 ${src}`) + chalk8.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk7.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk8.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -1303,35 +1434,35 @@ var unlinkOpenclaw = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk7.yellow("Cancelled."));
+      console.log(chalk8.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk7.red(`
+  console.log(chalk8.red(`
 Removing OpenClaw integration...`));
-  console.log(chalk7.dim(OPENCLAW_DIR));
+  console.log(chalk8.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 (fs7.existsSync(target) && fs7.lstatSync(target).isSymbolicLink()) {
+      fs7.unlinkSync(target);
+      console.log(chalk8.red("  removed symlink") + chalk8.dim(`: ${target}`));
     }
   }
-  if (fs6.existsSync(backupPath)) {
+  if (fs7.existsSync(backupPath)) {
     try {
       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)) {
+        if (!fs7.existsSync(src)) {
           continue;
         }
-        fs6.renameSync(src, dest);
-        console.log(chalk7.green("  restored") + chalk7.dim(`: ${dir}/`));
+        fs7.renameSync(src, dest);
+        console.log(chalk8.green("  restored") + chalk8.dim(`: ${dir}/`));
       }
-      fs6.rmdirSync(backupPath);
+      fs7.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk7.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
+      console.error(chalk8.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
     }
   }
   configManager.openclaw = null;
@@ -1340,8 +1471,8 @@ Removing OpenClaw integration...`));
 
 // src/link/antigravity.ts
 import path7 from "path";
-import fs7 from "fs";
-import chalk8 from "chalk";
+import fs8 from "fs";
+import chalk9 from "chalk";
 import { confirm as confirm6 } from "@inquirer/prompts";
 import { pathExists as pathExists3 } from "fs-extra";
 var linkAntigravity = async () => {
@@ -1349,44 +1480,44 @@ var linkAntigravity = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk8.green(`
+  console.log(chalk9.green(`
 Setting up Antigravity integration...`));
-  console.log(chalk8.dim(ANTIGRAVITY_DIR));
+  console.log(chalk9.dim(ANTIGRAVITY_DIR));
   const antigravityDirs = AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */];
   const backupExistingAntigravityFiles = async () => {
     try {
-      fs7.mkdirSync(ANTIGRAVITY_DIR, { recursive: true });
+      fs8.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) {
+        if (fs8.existsSync(target) && fs8.lstatSync(target).isSymbolicLink() === false && fs8.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
-      console.log(chalk8.yellow(`
+      console.log(chalk9.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(chalk9.dim(`    - ${path7.join(ANTIGRAVITY_DIR, dir)}`));
       }
-      console.log(chalk8.yellow(`  They will be backed up to: `) + chalk8.dim(ANTIGRAVITY_BACKUP_DIR));
+      console.log(chalk9.yellow(`  They will be backed up to: `) + chalk9.dim(ANTIGRAVITY_BACKUP_DIR));
       const ok = await confirm6({ message: "Back up existing directories?", default: true });
       if (!ok) {
-        console.log(chalk8.yellow("Skipped Antigravity linking."));
+        console.log(chalk9.yellow("Skipped Antigravity linking."));
         return false;
       }
-      fs7.mkdirSync(ANTIGRAVITY_BACKUP_DIR, { recursive: true });
+      fs8.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}`));
+        fs8.renameSync(src, dest);
+        console.log(chalk9.yellow("  backed up") + chalk9.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
-      console.error(chalk8.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      console.error(chalk9.red(`\u274C Failed to backup existing directories: ${ex.message}`));
       return false;
     }
   };
@@ -1399,21 +1530,21 @@ Setting up Antigravity integration...`));
         if (await pathExists3(src) === false) {
           continue;
         }
-        if (fs7.existsSync(dest)) {
-          fs7.rmSync(dest, { recursive: true, force: true });
+        if (fs8.existsSync(dest)) {
+          fs8.rmSync(dest, { recursive: true, force: true });
         }
         const symlinkType = process.platform === "win32" ? "junction" : "dir";
-        fs7.symlinkSync(src, dest, symlinkType);
+        fs8.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(chalk8.dim(`  ${branch} `) + chalk8.bold(`${dir}/`) + chalk8.dim(` \u2192 ${src}`) + chalk8.green(" \u2713"));
+        console.log(chalk9.dim(`  ${branch} `) + chalk9.bold(`${dir}/`) + chalk9.dim(` \u2192 ${src}`) + chalk9.green(" \u2713"));
       }
       return true;
     } catch (ex) {
-      console.error(chalk8.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      console.error(chalk9.red(`\u274C Failed to create symlinks: ${ex.message}`));
       return false;
     }
   };
@@ -1435,35 +1566,35 @@ var unlinkAntigravity = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk8.yellow("Cancelled."));
+      console.log(chalk9.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk8.red(`
+  console.log(chalk9.red(`
 Removing Antigravity integration...`));
-  console.log(chalk8.dim(ANTIGRAVITY_DIR));
+  console.log(chalk9.dim(ANTIGRAVITY_DIR));
   const backupPath = configManager.antigravity?.backup_path ?? ANTIGRAVITY_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
     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 (fs8.existsSync(target) && fs8.lstatSync(target).isSymbolicLink()) {
+      fs8.unlinkSync(target);
+      console.log(chalk9.red("  removed symlink") + chalk9.dim(`: ${target}`));
     }
   }
-  if (fs7.existsSync(backupPath)) {
+  if (fs8.existsSync(backupPath)) {
     try {
       for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
         const src = path7.join(backupPath, dir);
         const dest = path7.join(ANTIGRAVITY_DIR, dir);
-        if (!fs7.existsSync(src)) {
+        if (!fs8.existsSync(src)) {
           continue;
         }
-        fs7.renameSync(src, dest);
-        console.log(chalk8.green("  restored") + chalk8.dim(`: ${dir}/`));
+        fs8.renameSync(src, dest);
+        console.log(chalk9.green("  restored") + chalk9.dim(`: ${dir}/`));
       }
-      fs7.rmdirSync(backupPath);
+      fs8.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk8.red(`  \u274C Failed to restore Antigravity backup: ${ex.message}`));
+      console.error(chalk9.red(`  \u274C Failed to restore Antigravity backup: ${ex.message}`));
     }
   }
   configManager.antigravity = null;
@@ -1472,9 +1603,9 @@ Removing Antigravity integration...`));
 
 // src/link/codex.ts
 import path8 from "path";
-import fs8 from "fs";
+import fs9 from "fs";
 import os3 from "os";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 import { confirm as confirm7 } from "@inquirer/prompts";
 import TOML from "smol-toml";
 var CODEX_AGENTS_DIR = path8.join(os3.homedir(), ".agents", "plugins");
@@ -1496,16 +1627,16 @@ var linkCodex = async () => {
         interface: { displayName: "Local Repository" },
         plugins: []
       };
-      if (fs8.existsSync(marketplacePath)) {
-        const raw = fs8.readFileSync(marketplacePath, "utf-8");
+      if (fs9.existsSync(marketplacePath)) {
+        const raw = fs9.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."));
+          console.warn(chalk10.yellow("  \u26A0 Failed to parse marketplace.json \u2014 will not overwrite existing file"));
+          console.error(chalk10.red("\u274C Could not register plugin. Please add manually."));
           return false;
         }
       }
@@ -1528,58 +1659,58 @@ var linkCodex = async () => {
         category: "Productivity"
       });
       let backupPath = null;
-      if (fs8.existsSync(marketplacePath)) {
+      if (fs9.existsSync(marketplacePath)) {
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         backupPath = `${marketplacePath}.bak.${timestamp}`;
         try {
-          fs8.copyFileSync(marketplacePath, backupPath);
+          fs9.copyFileSync(marketplacePath, backupPath);
         } catch (ex) {
-          console.warn(chalk9.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
+          console.warn(chalk10.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");
+        fs9.mkdirSync(path8.dirname(marketplacePath), { recursive: true });
+        fs9.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."));
+            fs9.copyFileSync(backupPath, marketplacePath);
+            fs9.unlinkSync(backupPath);
+            console.warn(chalk10.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
           } catch {
-            console.error(chalk9.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+            console.error(chalk10.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
           }
         }
         throw ex;
       }
       if (backupPath !== null) {
         try {
-          fs8.unlinkSync(backupPath);
+          fs9.unlinkSync(backupPath);
         } catch {
         }
       }
       console.log(`\u2705 Registered to marketplace.json`);
-      console.log(chalk9.dim(`   ${marketplacePath}`));
+      console.log(chalk10.dim(`   ${marketplacePath}`));
       return true;
     } catch (ex) {
-      console.error(chalk9.red(`\u274C Failed to update marketplace.json: ${ex.message}`));
+      console.error(chalk10.red(`\u274C Failed to update marketplace.json: ${ex.message}`));
       return false;
     }
   };
   const patchPluginCache = () => {
     const cachePath = path8.join(CODEX_CACHE_DIR, CODEX_MARKETPLACE_NAME, PLUGIN_NAME, "1.0.0");
     try {
-      fs8.mkdirSync(path8.dirname(cachePath), { recursive: true });
-      if (fs8.existsSync(cachePath)) {
-        fs8.rmSync(cachePath, { recursive: true, force: true });
+      fs9.mkdirSync(path8.dirname(cachePath), { recursive: true });
+      if (fs9.existsSync(cachePath)) {
+        fs9.rmSync(cachePath, { recursive: true, force: true });
       }
       const symlinkType = process.platform === "win32" ? "junction" : "dir";
-      fs8.symlinkSync(repoPath, cachePath, symlinkType);
+      fs9.symlinkSync(repoPath, cachePath, symlinkType);
       console.log(`\u2705 Patched plugin cache.`);
-      console.log(chalk9.dim(`   ${cachePath}`) + chalk9.dim(" \u2192 ") + chalk9.dim(repoPath));
+      console.log(chalk10.dim(`   ${cachePath}`) + chalk10.dim(" \u2192 ") + chalk10.dim(repoPath));
     } catch (ex) {
-      console.warn(chalk9.yellow(`  \u26A0 Could not patch plugin cache: ${ex.message}`));
+      console.warn(chalk10.yellow(`  \u26A0 Could not patch plugin cache: ${ex.message}`));
     }
   };
   const enableInConfig = () => {
@@ -1587,22 +1718,22 @@ var linkCodex = async () => {
     const pluginKey = `${PLUGIN_NAME}@${CODEX_MARKETPLACE_NAME}`;
     try {
       let config = {};
-      if (fs8.existsSync(configPath)) {
-        config = TOML.parse(fs8.readFileSync(configPath, "utf-8"));
+      if (fs9.existsSync(configPath)) {
+        config = TOML.parse(fs9.readFileSync(configPath, "utf-8"));
       }
       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");
+      fs9.mkdirSync(path8.dirname(configPath), { recursive: true });
+      fs9.writeFileSync(configPath, TOML.stringify(config), "utf-8");
       console.log(`\u2705 Enabled plugin in config.toml`);
-      console.log(chalk9.dim(`   ${configPath}`));
+      console.log(chalk10.dim(`   ${configPath}`));
     } catch (ex) {
-      console.warn(chalk9.yellow(`  \u26A0 Could not update config.toml: ${ex.message}`));
+      console.warn(chalk10.yellow(`  \u26A0 Could not update config.toml: ${ex.message}`));
     }
   };
-  console.log(chalk9.green(`
+  console.log(chalk10.green(`
 Setting up Codex plugin...`));
   const marketplaceOk = registerToMarketplace();
   if (marketplaceOk === false) {
@@ -1620,55 +1751,55 @@ var unlinkCodex = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk9.yellow("Cancelled."));
+      console.log(chalk10.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk9.red(`
+  console.log(chalk10.red(`
 Removing Codex plugin...`));
   const marketplacePath = path8.join(CODEX_AGENTS_DIR, "marketplace.json");
-  if (fs8.existsSync(marketplacePath)) {
+  if (fs9.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"));
+      fs9.copyFileSync(marketplacePath, backupPath);
+      const marketplace = JSON.parse(fs9.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}`));
+        fs9.writeFileSync(marketplacePath, JSON.stringify(marketplace, null, 4), "utf-8");
+        fs9.unlinkSync(backupPath);
+        console.log(chalk10.red("  removed") + chalk10.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."));
+        fs9.copyFileSync(backupPath, marketplacePath);
+        fs9.unlinkSync(backupPath);
+        console.warn(chalk10.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
       }
     } catch (ex) {
-      console.error(chalk9.red(`  \u274C Failed to clean up marketplace.json: ${ex.message}`));
+      console.error(chalk10.red(`  \u274C Failed to clean up marketplace.json: ${ex.message}`));
     }
   }
   const configPath = path8.join(os3.homedir(), ".codex", "config.toml");
-  if (fs8.existsSync(configPath)) {
+  if (fs9.existsSync(configPath)) {
     try {
-      const config = TOML.parse(fs8.readFileSync(configPath, "utf-8"));
+      const config = TOML.parse(fs9.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}`));
+        fs9.writeFileSync(configPath, TOML.stringify(config), "utf-8");
+        console.log(chalk10.red("  removed") + chalk10.dim(` ${pluginKey} from: ${configPath}`));
       }
     } catch (ex) {
-      console.error(chalk9.red(`  \u274C Failed to clean up config.toml: ${ex.message}`));
+      console.error(chalk10.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}`));
+  if (fs9.existsSync(cacheMarketDir)) {
+    fs9.rmSync(cacheMarketDir, { recursive: true, force: true });
+    console.log(chalk10.red("  removed") + chalk10.dim(`: ${cacheMarketDir}`));
   }
   configManager.codex = null;
   configManager.save();
@@ -1676,8 +1807,8 @@ Removing Codex plugin...`));
 
 // src/link/cursor.ts
 import path9 from "path";
-import fs9 from "fs";
-import chalk10 from "chalk";
+import fs10 from "fs";
+import chalk11 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");
@@ -1686,35 +1817,35 @@ var linkCursor = async () => {
   if (repoPath == null) {
     return;
   }
-  console.log(chalk10.green(`
+  console.log(chalk11.green(`
 Setting up Cursor integration...`));
-  console.log(chalk10.dim(CURSOR_DIR));
+  console.log(chalk11.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) {
+    if (fs10.existsSync(target) && fs10.lstatSync(target).isSymbolicLink() === false && fs10.readdirSync(target).length > 0) {
       dirsToBackup.push(dir);
     }
   }
   if (dirsToBackup.length > 0) {
-    console.log(chalk10.yellow(`
+    console.log(chalk11.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(chalk11.dim(`    - ${path9.join(CURSOR_DIR, dir)}`));
     }
-    console.log(chalk10.yellow(`  They will be backed up to: `) + chalk10.dim(CURSOR_BACKUP_DIR));
+    console.log(chalk11.yellow(`  They will be backed up to: `) + chalk11.dim(CURSOR_BACKUP_DIR));
     const ok = await confirm8({ message: "Back up existing directories?", default: true });
     if (!ok) {
-      console.log(chalk10.yellow("Skipped Cursor linking."));
+      console.log(chalk11.yellow("Skipped Cursor linking."));
       return;
     }
-    fs9.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
+    fs10.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}`));
+      fs10.renameSync(src, dest);
+      console.log(chalk11.yellow("  backed up") + chalk11.dim(`: ${dir}/ \u2192 ${dest}`));
     }
   }
   try {
@@ -1725,33 +1856,33 @@ Setting up Cursor integration...`));
       if (await pathExists4(src) === false) {
         continue;
       }
-      if (fs9.existsSync(dest)) {
-        fs9.rmSync(dest, { recursive: true, force: true });
+      if (fs10.existsSync(dest)) {
+        fs10.rmSync(dest, { recursive: true, force: true });
       }
       const symlinkType = process.platform === "win32" ? "junction" : "dir";
-      fs9.symlinkSync(src, dest, symlinkType);
+      fs10.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"));
+      console.log(chalk11.dim(`  \u251C\u2500\u2500 `) + chalk11.bold(`${dir}/`) + chalk11.dim(` \u2192 ${src}`) + chalk11.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) {
+    if (fs10.existsSync(mcpSrc)) {
+      if (fs10.existsSync(mcpDest) && fs10.statSync(mcpDest).ino !== fs10.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}`));
+        fs10.mkdirSync(CURSOR_BACKUP_DIR, { recursive: true });
+        fs10.renameSync(mcpDest, mcpBackup);
+        console.log(chalk11.yellow("  backed up") + chalk11.dim(`: mcp.json \u2192 ${mcpBackup}`));
       }
-      if (fs9.existsSync(mcpDest)) {
-        fs9.unlinkSync(mcpDest);
+      if (fs10.existsSync(mcpDest)) {
+        fs10.unlinkSync(mcpDest);
       }
-      fs9.linkSync(mcpSrc, mcpDest);
-      console.log(chalk10.dim(`  \u2514\u2500\u2500 `) + chalk10.bold("mcp.json") + chalk10.dim(` \u21D4 ${mcpSrc}`) + chalk10.green(" \u2713"));
+      fs10.linkSync(mcpSrc, mcpDest);
+      console.log(chalk11.dim(`  \u2514\u2500\u2500 `) + chalk11.bold("mcp.json") + chalk11.dim(` \u21D4 ${mcpSrc}`) + chalk11.green(" \u2713"));
     }
   } catch (ex) {
-    console.error(chalk10.red(`\u274C Failed to set up Cursor: ${ex.message}`));
+    console.error(chalk11.red(`\u274C Failed to set up Cursor: ${ex.message}`));
     return;
   }
   configManager.cursor = { path: CURSOR_DIR, backup_path: CURSOR_BACKUP_DIR };
@@ -1764,45 +1895,45 @@ var unlinkCursor = async (force = false) => {
       default: false
     });
     if (!ok) {
-      console.log(chalk10.yellow("Cancelled."));
+      console.log(chalk11.yellow("Cancelled."));
       return;
     }
   }
-  console.log(chalk10.red(`
+  console.log(chalk11.red(`
 Removing Cursor integration...`));
-  console.log(chalk10.dim(CURSOR_DIR));
+  console.log(chalk11.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}`));
+    if (fs10.existsSync(target) && fs10.lstatSync(target).isSymbolicLink()) {
+      fs10.unlinkSync(target);
+      console.log(chalk11.red("  removed symlink") + chalk11.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 (fs10.existsSync(mcpDest)) {
+    fs10.unlinkSync(mcpDest);
+    console.log(chalk11.red("  removed") + chalk11.dim(`: ${mcpDest}`));
   }
-  if (fs9.existsSync(backupPath)) {
+  if (fs10.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)) {
+        if (!fs10.existsSync(src)) {
           continue;
         }
-        fs9.renameSync(src, dest);
-        console.log(chalk10.green("  restored") + chalk10.dim(`: ${dir}/`));
+        fs10.renameSync(src, dest);
+        console.log(chalk11.green("  restored") + chalk11.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`));
+      if (fs10.existsSync(mcpBackup)) {
+        fs10.renameSync(mcpBackup, mcpDest);
+        console.log(chalk11.green("  restored") + chalk11.dim(`: mcp.json`));
       }
-      fs9.rmSync(backupPath, { recursive: true, force: true });
+      fs10.rmSync(backupPath, { recursive: true, force: true });
     } catch (ex) {
-      console.error(chalk10.red(`  \u274C Failed to restore Cursor backup: ${ex.message}`));
+      console.error(chalk11.red(`  \u274C Failed to restore Cursor backup: ${ex.message}`));
     }
   }
   configManager.cursor = null;
@@ -1830,7 +1961,7 @@ var linkCommand = async (tool) => {
   if (tool != null) {
     const known = ALL_AGENTS.some((a) => a.value === tool);
     if (!known) {
-      console.log(chalk11.red(`Unknown vendor: ${tool}`));
+      console.log(chalk12.red(`Unknown vendor: ${tool}`));
       process.exit(1);
     }
     await LINK_MAP[tool]();
@@ -1847,7 +1978,7 @@ var linkCommand = async (tool) => {
   const selected = await checkbox({
     message: "Which AI agent do you want to integrate?",
     choices: ALL_AGENTS.map((a) => ({
-      name: prevLinked[a.value] ? `${a.name} ${chalk11.dim("(applied)")}` : a.name,
+      name: prevLinked[a.value] ? `${a.name} ${chalk12.dim("(applied)")}` : a.name,
       value: a.value,
       checked: prevLinked[a.value]
     }))
@@ -1856,10 +1987,10 @@ var linkCommand = async (tool) => {
   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(", ")));
+    console.log(chalk12.green("  Link   ") + chalk12.dim("\u2192 ") + toLink.map((a) => chalk12.bold(a.name)).join(chalk12.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(chalk12.red("  Unlink ") + chalk12.dim("\u2192 ") + toUnlink.map((a) => chalk12.bold(a.name)).join(chalk12.dim(", ")));
   }
   console.log();
   if (toLink.length === 0 && toUnlink.length === 0) {
@@ -1878,14 +2009,14 @@ var linkCommand = async (tool) => {
 };
 
 // src/commands/uninstall-command.ts
-import fs10 from "fs";
-import chalk12 from "chalk";
+import fs11 from "fs";
+import chalk13 from "chalk";
 import { confirm as confirm9 } from "@inquirer/prompts";
 var uninstallCommand = async () => {
   const targets = [
-    { 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));
+    { label: `Config file  ${chalk13.dim(CONFIG_PATH)}`, path: CONFIG_PATH },
+    { label: `Home dir     ${chalk13.dim(HOME_DIR)}`, path: HOME_DIR }
+  ].filter((t) => fs11.existsSync(t.path));
   const hasClaudeCode = configManager.isClaudeCodeEnabled();
   const hasRooCode = configManager.isRooCodeEnabled();
   const hasOpenclaw = configManager.isOpenclawEnabled();
@@ -1893,32 +2024,32 @@ var uninstallCommand = async () => {
   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."));
+    console.log(chalk13.yellow("Nothing to remove."));
     return;
   }
-  console.log(chalk12.red("\nThe following will be removed:"));
+  console.log(chalk13.red("\nThe following will be removed:"));
   targets.forEach((t) => console.log(`  ${t.label}`));
   if (hasClaudeCode) {
-    console.log(`  Claude Code plugin dir  ${chalk12.dim(CLAUDE_CODE_DIR)}`);
+    console.log(`  Claude Code plugin dir  ${chalk13.dim(CLAUDE_CODE_DIR)}`);
   }
   if (hasRooCode) {
-    console.log(`  RooCode symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  RooCode symlinks ${chalk13.dim("(backup will be restored)")}`);
   }
   if (hasOpenclaw) {
-    console.log(`  OpenClaw symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  OpenClaw symlinks ${chalk13.dim("(backup will be restored)")}`);
   }
   if (hasAntigravity) {
-    console.log(`  Antigravity symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  Antigravity symlinks ${chalk13.dim("(backup will be restored)")}`);
   }
   if (hasCodex) {
-    console.log(`  Codex symlinks ${chalk12.dim("(backup will be restored)")}`);
+    console.log(`  Codex symlinks ${chalk13.dim("(backup will be restored)")}`);
   }
   if (hasCursor) {
-    console.log(`  Cursor plugin dir ${chalk12.dim("(symlink will be removed)")}`);
+    console.log(`  Cursor plugin dir ${chalk13.dim("(symlink will be removed)")}`);
   }
   const ok = await confirm9({ message: "Proceed?", default: false });
   if (!ok) {
-    console.log(chalk12.yellow("Cancelled."));
+    console.log(chalk13.yellow("Cancelled."));
     return;
   }
   if (hasClaudeCode) {
@@ -1940,26 +2071,26 @@ var uninstallCommand = async () => {
     await unlinkCursor(true);
   }
   for (const t of targets) {
-    fs10.rmSync(t.path, { recursive: true, force: true });
-    console.log(chalk12.dim(`  removed: ${t.path}`));
+    fs11.rmSync(t.path, { recursive: true, force: true });
+    console.log(chalk13.dim(`  removed: ${t.path}`));
   }
-  console.log(chalk12.green("\nUninstalled."));
+  console.log(chalk13.green("\nUninstalled."));
 };
 
 // src/commands/status-command.ts
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 var statusCommand = () => {
   if (configManager.repo_path == null) {
-    console.log(chalk13.yellow("\u274C No repo installed."));
-    console.log(chalk13.dim(`  Run: set-prompt install <repo-url>`));
+    console.log(chalk14.yellow("\u274C No repo installed."));
+    console.log(chalk14.dim(`  Run: set-prompt install <repo-url>`));
     return;
   }
-  console.log(chalk13.bold("\nRepo"));
-  console.log(`${TAB}path   ${chalk13.cyan(configManager.repo_path)}`);
+  console.log(chalk14.bold("\nRepo"));
+  console.log(`${TAB}path   ${chalk14.cyan(configManager.repo_path)}`);
   if (configManager.remote_url != null) {
-    console.log(`${TAB}remote ${chalk13.dim(configManager.remote_url)}`);
+    console.log(`${TAB}remote ${chalk14.dim(configManager.remote_url)}`);
   }
-  console.log(chalk13.bold("\nLinked agents"));
+  console.log(chalk14.bold("\nLinked agents"));
   for (const agent of ALL_AGENTS) {
     let linked = false;
     let agentPath = null;
@@ -1979,78 +2110,363 @@ var statusCommand = () => {
       linked = configManager.isAntigravityEnabled();
       agentPath = configManager.antigravity?.path;
     }
-    const label = linked ? chalk13.green("linked") : chalk13.dim("not linked");
-    const pathStr = linked && agentPath ? chalk13.dim(` \u2192 ${agentPath}`) : "";
+    const label = linked ? chalk14.green("linked") : chalk14.dim("not linked");
+    const pathStr = linked && agentPath ? chalk14.dim(` \u2192 ${agentPath}`) : "";
     console.log(`${TAB}${agent.name.padEnd(12)} ${label}${pathStr}`);
   }
   console.log("");
 };
 
-// src/commands/update-command.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import chalk14 from "chalk";
-var updateCommand = () => {
+// src/commands/repo/pull-command.ts
+import { spawnSync as spawnSync4 } from "child_process";
+import chalk15 from "chalk";
+var repoPullCommand = () => {
   const repoPath = configManager.repo_path;
   if (repoPath == null) {
-    console.error(chalk14.red("\u274C No repo installed."));
-    console.log(chalk14.yellow("Run: set-prompt install <git-url>"));
+    console.error(chalk15.red("\u274C No repo installed."));
+    console.log(chalk15.yellow("Run: set-prompt install <git-url>"));
     return;
   }
   if (configManager.remote_url == null) {
-    console.error(chalk14.red("\u274C No remote URL registered. Cannot update."));
+    console.error(chalk15.red("\u274C No remote URL registered. Cannot pull."));
     return;
   }
-  console.log(chalk14.green("\nUpdating prompt repo..."));
-  console.log(chalk14.dim(repoPath));
-  const fetch = spawnSync2("git", ["fetch"], { cwd: repoPath, stdio: "inherit" });
+  console.log(chalk15.green("\nPulling prompt repo..."));
+  console.log(chalk15.dim(repoPath));
+  const fetch = spawnSync4("git", ["fetch"], { cwd: repoPath, stdio: "inherit" });
   if (fetch.status !== 0) {
-    console.error(chalk14.red("\u274C git fetch failed."));
+    console.error(chalk15.red("\u274C git fetch failed."));
     return;
   }
-  const pull = spawnSync2("git", ["pull"], { cwd: repoPath, stdio: "inherit" });
+  const pull = spawnSync4("git", ["pull"], { cwd: repoPath, stdio: "inherit" });
   if (pull.status !== 0) {
-    console.error(chalk14.red("\u274C git pull failed."));
+    console.error(chalk15.red("\u274C git pull failed."));
+    return;
+  }
+  console.log(chalk15.green("\u2705 Repo pulled."));
+};
+
+// src/commands/repo/commit-command.ts
+import { spawnSync as spawnSync5 } from "child_process";
+import chalk16 from "chalk";
+var repoCommitCommand = (options = {}) => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk16.red("\u274C No repo installed."));
+    console.log(chalk16.yellow("Run: set-prompt install <git-url>"));
+    return false;
+  }
+  let message = options.message;
+  if (message == null || message.trim() === "") {
+    const generated = generateCommitMessage(repoPath);
+    if (generated == null) {
+      console.error(chalk16.red("\u274C Nothing to commit \u2014 working tree is clean."));
+      return false;
+    }
+    message = generated;
+    const subject = message.split("\n")[0];
+    console.log(chalk16.dim(`  (auto-generated: ${subject})`));
+  }
+  console.log(chalk16.green("\nCommitting prompt repo changes..."));
+  console.log(chalk16.dim(repoPath));
+  const add = spawnSync5("git", ["add", "-A"], { cwd: repoPath, stdio: "inherit" });
+  if (add.status !== 0) {
+    console.error(chalk16.red("\u274C git add failed."));
+    return false;
+  }
+  const commit = spawnSync5("git", ["commit", "-m", message], { cwd: repoPath, stdio: "inherit" });
+  if (commit.status !== 0) {
+    console.error(chalk16.red("\u274C git commit failed \u2014 nothing to commit, or commit rejected."));
+    return false;
+  }
+  console.log(chalk16.green("\u2705 Committed."));
+  return true;
+};
+
+// src/commands/repo/push-command.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import chalk17 from "chalk";
+var repoPushCommand = () => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk17.red("\u274C No repo installed."));
+    console.log(chalk17.yellow("Run: set-prompt install <git-url>"));
+    return false;
+  }
+  if (configManager.remote_url == null) {
+    console.error(chalk17.red("\u274C No remote URL registered. Cannot push."));
+    return false;
+  }
+  console.log(chalk17.green("\nPushing prompt repo..."));
+  console.log(chalk17.dim(repoPath));
+  const push = spawnSync6("git", ["push"], { cwd: repoPath, stdio: "inherit" });
+  if (push.status !== 0) {
+    console.error(chalk17.red("\u274C git push failed."));
+    return false;
+  }
+  console.log(chalk17.green("\u2705 Pushed."));
+  return true;
+};
+
+// src/commands/repo/save-command.ts
+var repoSaveCommand = (options = {}) => {
+  const committed = repoCommitCommand({ message: options.message });
+  if (committed === false) return;
+  repoPushCommand();
+};
+
+// src/commands/repo/status-command.ts
+import { spawnSync as spawnSync7 } from "child_process";
+import chalk18 from "chalk";
+var parseBranchLine = (line) => {
+  const body = line.replace(/^## /, "");
+  if (body.startsWith("HEAD ") || body.includes("(no branch)")) {
+    return { branch: null, upstream: null, ahead: 0, behind: 0 };
+  }
+  const [refPart, bracketPart] = body.split(/\s+(?=\[)/);
+  const [branch, upstream] = refPart.split("...");
+  let ahead = 0;
+  let behind = 0;
+  if (bracketPart != null) {
+    const inside = bracketPart.replace(/[\[\]]/g, "");
+    for (const piece of inside.split(",").map((s) => s.trim())) {
+      const m = piece.match(/^(ahead|behind) (\d+)$/);
+      if (m == null) continue;
+      if (m[1] === "ahead") ahead = Number(m[2]);
+      if (m[1] === "behind") behind = Number(m[2]);
+    }
+  }
+  return { branch: branch ?? null, upstream: upstream ?? null, ahead, behind };
+};
+var parseFileLine = (line) => {
+  if (line.length < 4) return null;
+  const status = line.slice(0, 2);
+  let name = line.slice(3);
+  const arrowIdx = name.indexOf(" -> ");
+  if (arrowIdx >= 0) name = name.slice(arrowIdx + 4);
+  if (name.startsWith('"') && name.endsWith('"')) name = name.slice(1, -1);
+  if (status.includes("?")) return { label: "untracked", color: chalk18.gray, path: name };
+  if (status.includes("D")) return { label: "deleted", color: chalk18.red, path: name };
+  if (status.includes("R")) return { label: "renamed", color: chalk18.cyan, path: name };
+  if (status.includes("A")) return { label: "added", color: chalk18.green, path: name };
+  if (status.includes("M")) return { label: "modified", color: chalk18.yellow, path: name };
+  return null;
+};
+var formatUpstream = (info) => {
+  if (info.branch == null) return chalk18.red("(detached HEAD)");
+  if (info.upstream == null) return `${info.branch} ${chalk18.yellow("(no upstream)")}`;
+  const segs = [];
+  if (info.ahead > 0) segs.push(chalk18.green(`ahead ${info.ahead}`));
+  if (info.behind > 0) segs.push(chalk18.red(`behind ${info.behind}`));
+  const trailing = segs.length > 0 ? ` (${segs.join(", ")})` : chalk18.dim(" (up to date)");
+  return `${info.branch} ${chalk18.dim("\u2192")} ${info.upstream}${trailing}`;
+};
+var repoStatusCommand = () => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk18.red("\u274C No repo installed."));
+    console.log(chalk18.yellow("Run: set-prompt install <git-url>"));
+    return;
+  }
+  const result = spawnSync7("git", ["status", "--porcelain=v1", "--branch", "--untracked-files=all"], {
+    cwd: repoPath,
+    encoding: "utf8"
+  });
+  if (result.status !== 0) {
+    console.error(chalk18.red("\u274C git status failed."));
+    if (result.stderr) console.error(chalk18.dim(result.stderr));
+    return;
+  }
+  const lines = result.stdout.split("\n").filter((l) => l.length > 0);
+  const branchLine = lines[0] ?? "## (unknown)";
+  const fileLines = lines.slice(1);
+  const branchInfo = parseBranchLine(branchLine);
+  const changes = fileLines.map(parseFileLine).filter((f) => f !== null);
+  console.log(`${chalk18.cyan("\u{1F4C2}")} ${chalk18.dim(repoPath)}`);
+  console.log(`${chalk18.cyan("\u{1F33F}")} ${formatUpstream(branchInfo)}`);
+  console.log("");
+  if (changes.length === 0) {
+    console.log(chalk18.green("\u2705 Working tree clean"));
     return;
   }
-  console.log(chalk14.green("\u2705 Repo updated."));
+  console.log(chalk18.bold(`\u{1F4DD} Changes (${changes.length}):`));
+  const labelWidth = Math.max(...changes.map((c) => c.label.length));
+  for (const c of changes) {
+    const label = c.color(c.label.padEnd(labelWidth));
+    console.log(`   ${label}  ${c.path}`);
+  }
+};
+
+// src/commands/repo/path-command.ts
+import chalk19 from "chalk";
+var repoPathCommand = () => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk19.red("\u274C No repo installed."));
+    console.error(chalk19.yellow("Run: set-prompt install <git-url>"));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(repoPath);
+};
+
+// src/commands/repo/open-command.ts
+import { spawn } from "child_process";
+import path10 from "path";
+import chalk20 from "chalk";
+var resolveVscodeTarget = (repoPath) => {
+  if (isOnPath("code") === false) return null;
+  return { bin: "code", args: [repoPath] };
+};
+var resolveSourcetreeTarget = (repoPath) => {
+  if (isOnPath("stree")) {
+    return { bin: "stree", args: [repoPath] };
+  }
+  if (process.platform === "win32") {
+    const exe = firstExistingPath([
+      process.env.LOCALAPPDATA && path10.join(process.env.LOCALAPPDATA, "SourceTree", "SourceTree.exe"),
+      process.env["ProgramFiles(x86)"] && path10.join(process.env["ProgramFiles(x86)"], "Atlassian", "SourceTree", "SourceTree.exe"),
+      process.env.ProgramFiles && path10.join(process.env.ProgramFiles, "Atlassian", "SourceTree", "SourceTree.exe")
+    ]);
+    if (exe != null) return { bin: exe, args: ["-f", repoPath] };
+  }
+  return null;
+};
+var VSCODE_INSTALL_HINT = `Install VSCode CLI: View \u2192 Command Palette \u2192 "Shell Command: Install 'code' command"`;
+var sourcetreeInstallHint = () => {
+  if (process.platform === "darwin") {
+    return 'Install Sourcetree, then: Sourcetree menu bar \u2192 "Install Command Line Tools"';
+  }
+  if (process.platform === "win32") {
+    return "Install Sourcetree from https://sourcetreeapp.com/ \u2014 this CLI auto-detects it at %LOCALAPPDATA%\\SourceTree";
+  }
+  return "Sourcetree is not available on Linux \u2014 try a native Git GUI instead";
+};
+var runLaunch = (label, target) => {
+  console.log(chalk20.green(`Opening in ${label}: ${chalk20.dim(target.args[target.args.length - 1])}`));
+  const child = spawn(target.bin, target.args, { stdio: "ignore", detached: true, shell: true });
+  child.unref();
+};
+var repoOpenCommand = (options = {}) => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk20.red("\u274C No repo installed."));
+    console.log(chalk20.yellow("Run: set-prompt install <git-url>"));
+    return;
+  }
+  if (options.code === true) {
+    const target = resolveVscodeTarget(repoPath);
+    if (target == null) {
+      console.error(chalk20.red("\u274C VSCode CLI (`code`) not found on PATH."));
+      console.log(chalk20.dim(`   ${VSCODE_INSTALL_HINT}`));
+      return;
+    }
+    runLaunch("VSCode", target);
+    return;
+  }
+  if (options.stree === true) {
+    const target = resolveSourcetreeTarget(repoPath);
+    if (target == null) {
+      console.error(chalk20.red("\u274C Sourcetree not found."));
+      console.log(chalk20.dim(`   ${sourcetreeInstallHint()}`));
+      return;
+    }
+    runLaunch("Sourcetree", target);
+    return;
+  }
+  const platform = process.platform;
+  const opener = platform === "win32" ? "explorer" : platform === "darwin" ? "open" : "xdg-open";
+  console.log(chalk20.green(`Opening: ${chalk20.dim(repoPath)}`));
+  const child = spawn(opener, [repoPath], { stdio: "ignore", detached: true });
+  child.on("error", (ex) => {
+    console.error(chalk20.red(`\u274C Failed to open: ${ex.message}`));
+  });
+  child.unref();
 };
 
 // src/index.ts
 process.on("SIGINT", () => {
-  console.log(chalk15.yellow("\nCancelled."));
+  console.log(chalk21.yellow("\nCancelled."));
   process.exit(0);
 });
 process.on("unhandledRejection", (reason) => {
   if (reason instanceof Error && reason.name === "ExitPromptError") {
-    console.log(chalk15.yellow("\nCancelled."));
+    console.log(chalk21.yellow("\nCancelled."));
     process.exit(0);
   }
   throw reason;
 });
-var __dirname = path10.dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(fs11.readFileSync(path10.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path11.dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(fs12.readFileSync(path11.join(__dirname, "../package.json"), "utf-8"));
 configManager.init();
 var program = new Command();
-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 ${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) => {
+var banner = chalk21.cyan(figlet.textSync("Set-Prompt", { horizontalLayout: "full" }));
+program.name("set-prompt").description(pkg.description).version(pkg.version).addHelpText("beforeAll", ({ command }) => command === program ? banner + "\n" : "");
+program.command("install").description(`\u{1F4E6} Clone a ${chalk21.cyan("git repo")} into ${chalk21.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 ${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) => {
+program.command("link").description(`\u{1F517} Symlink your prompt repo into an ${chalk21.cyan("AI agent")} plugin dir ${chalk21.dim("(claudecode | roocode | openclaw | codex | antigravity)")}`).argument("[agent]", `target agent ${chalk21.dim("(omit for interactive selection)")}`).action(async (agent) => {
   await linkCommand(agent);
 });
-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) => {
+program.command("scaffold").description(`\u{1F6E0}\uFE0F  Verify and create ${chalk21.cyan("required directories")} in a prompt repo ${chalk21.dim("(-f to force overwrite)")}`).argument("[path]", `path to repo ${chalk21.dim("(defaults to installed source)")}`).action(async (localPath) => {
   await scaffoldCommand(localPath);
 });
-program.command("status").description(`\u{1F4CB} Show registered ${chalk15.cyan("repo")} and which ${chalk15.cyan("agents")} are linked`).action(() => {
+program.command("status").description(`\u{1F4CB} Show registered ${chalk21.cyan("repo")} and which ${chalk21.cyan("agents")} are linked`).action(() => {
   statusCommand();
 });
-program.command("update").description(`\u{1F504} Fetch and pull the latest changes from the ${chalk15.cyan("remote repo")}`).action(() => {
-  updateCommand();
+var repo = program.command("repo").description(`\u{1F5C2}\uFE0F  Manage the installed prompt repo ${chalk21.dim("(status | pull | commit | push | save | path | open)")}`);
+repo.command("status").description(`\u{1F4CB} Show VCS status of the repo ${chalk21.dim("(branch, ahead/behind, changed files)")}`).addHelpText("after", `
+Example output:
+  \u{1F4C2} ~/.set-prompt/repo
+  \u{1F33F} main \u2192 origin/main (ahead 2)
+
+  \u{1F4DD} Changes (2):
+     modified   skills/foo.md
+     untracked  draft.md
+`).action(() => {
+  repoStatusCommand();
+});
+repo.command("pull").description(`\u{1F504} Fetch and pull the latest changes from the ${chalk21.cyan("remote repo")}`).action(() => {
+  repoPullCommand();
+});
+repo.command("commit").description(`\u{1F4DD} Stage all changes and commit ${chalk21.dim("(auto-generates message if -m omitted; does not push)")}`).option("-m, --message <msg>", "commit message (auto-generated from changed files if omitted)").addHelpText("after", `
+Examples:
+  $ sppt repo commit -m "edit dbml skill"
+  $ sppt repo commit                          ${chalk21.dim('# auto-generates "update N files" + file list')}
+`).action((opts) => {
+  repoCommitCommand({ message: opts.message });
+});
+repo.command("push").description(`\u2B06\uFE0F  Push local commits to the remote`).action(() => {
+  repoPushCommand();
+});
+repo.command("save").description(`\u{1F4BE} Stage + commit + push in one step ${chalk21.dim("(macro for commit \u2192 push; auto-generates message if -m omitted)")}`).option("-m, --message <msg>", "commit message (auto-generated from changed files if omitted)").addHelpText("after", `
+Examples:
+  $ sppt repo save -m "edit dbml skill"
+  $ sppt repo save                            ${chalk21.dim("# auto-generates message and pushes")}
+
+Equivalent to: sppt repo commit && sppt repo push
+`).action((opts) => {
+  repoSaveCommand({ message: opts.message });
+});
+repo.command("path").description(`\u{1F4CD} Print the repo path to stdout ${chalk21.dim("(e.g. cd $(sppt repo path))")}`).addHelpText("after", `
+Examples:
+  $ sppt repo path
+  ${chalk21.dim("/Users/me/.set-prompt/repo")}
+
+  $ cd "$(sppt repo path)"                    ${chalk21.dim("# jump into the repo")}
+  $ code "$(sppt repo path)"                  ${chalk21.dim("# open in VSCode")}
+`).action(() => {
+  repoPathCommand();
+});
+repo.command("open").description(`\u{1F4C2} Open the repo in the OS file manager ${chalk21.dim("(--code: VSCode, --stree: Sourcetree)")}`).option("--code", "open with VSCode (`code` CLI)").option("--stree", "open with Sourcetree (`stree` CLI)").addHelpText("after", `
+Examples:
+  $ sppt repo open                            ${chalk21.dim("# Explorer / Finder / xdg-open")}
+  $ sppt repo open --code                     ${chalk21.dim("# open in VSCode")}
+  $ sppt repo open --stree                    ${chalk21.dim("# open in Sourcetree")}
+`).action((opts) => {
+  repoOpenCommand({ code: opts.code, stree: opts.stree });
 });
-program.command("uninstall").description(`\u{1F5D1}\uFE0F  Remove all set-prompt data ${chalk15.dim("(~/.set-prompt/, plugin dirs, settings entries)")}`).action(async () => {
+program.command("uninstall").description(`\u{1F5D1}\uFE0F  Remove all set-prompt data ${chalk21.dim("(~/.set-prompt/, plugin dirs, settings entries)")}`).action(async () => {
   await uninstallCommand();
 });
 program.parse(process.argv);