soulhubcli 1.0.21 → 1.0.22

package/README.md

@@ -34,14 +34,41 @@ npx soulhubcli <command>
 
 | 命令 | 说明 |
 |------|------|
-| `soulhub search <keyword>` | 搜索 Agent |
+| `soulhub search [query]` | 搜索 Agent 模板（匹配名称、描述、标签） |
+| `soulhub search -c <category>` | 按分类筛选搜索结果 |
+| `soulhub search -n <number>` | 限制搜索结果数量（默认 20） |
+| `soulhub search --json` | 以 JSON 格式输出搜索结果 |
 | `soulhub info <name>` | 查看 Agent 详细信息（identity、soul、skills 等） |
-| `soulhub install <name>` | 从 Registry 安装 Agent 或团队（默认为 worker，安装到所有检测到的 claw） |
-| `soulhub install <name> --main` | 安装为主 Agent |
+| `soulhub info <name> --identity` | 显示 IDENTITY.md 内容 |
+| `soulhub info <name> --soul` | 显示 SOUL.md 内容 |
+| `soulhub info <name> --json` | 以 JSON 格式输出 Agent 详情 |
+| `soulhub install <name>` | 从 Registry 安装 Agent 或团队（交互式：选择角色和目标 claw） |
+| `soulhub install <name> --role main` | 安装为主 Agent（跳过角色选择） |
+| `soulhub install <name> --role worker` | 安装为 Worker Agent（跳过角色选择） |
+| `soulhub install <name> --claw-type <type>` | 指定 claw 类型（跳过 claw 选择） |
+| `soulhub install <name> --dir <path>` | 安装到指定目录（不依赖 claw 环境） |
+| `soulhub install <name> -y` | 跳过所有确认提示（自动确认） |
 | `soulhub install --from <source>` | 从本地目录、ZIP 文件或 URL 安装 |
 | `soulhub list` | 列出已安装的 Agent |
-| `soulhub update [name]` | 更新已安装的 Agent |
-| `soulhub rollback` | 回滚到上一次安装状态 |
+| `soulhub list --json` | 以 JSON 格式输出已安装的 Agent |
+| `soulhub update [name]` | 更新已安装的 Agent（不传名称则更新全部） |
+| `soulhub uninstall <name>` | 卸载 Agent（同时删除相关备份） |
+| `soulhub uninstall <name> --keep-files` | 卸载但保留 workspace 文件 |
+| `soulhub uninstall <name> -y` | 卸载 Agent（跳过确认提示） |
+| `soulhub rollback` | 交互式选择回滚到某次安装前的状态 |
+| `soulhub rollback --list` | 列出所有可用的回滚记录 |
+| `soulhub rollback --last <n>` | 回滚倒数第 n 次安装（1 = 最近一次） |
+| `soulhub rollback --id <id>` | 按 ID 回滚到指定的备份记录 |
+| `soulhub rollback --claw-type <type>` | 指定回滚的目标 claw 类型 |
+| `soulhub rollback --last <n> -y` | 回滚并跳过确认提示 |
+
+### 全局选项
+
+| 选项 | 说明 |
+|------|------|
+| `--verbose` | 启用详细调试日志 |
+| `--version` | 显示版本号 |
+| `--help` | 显示帮助信息 |
 
 ## 使用方法
 
@@ -50,22 +77,41 @@ npx soulhubcli <command>
 ```bash
 soulhub search python
 soulhub search "content writing"
+
+# 按分类筛选
+soulhub search -c development
+
+# 限制结果数量
+soulhub search writer -n 5
+
+# JSON 格式输出（适合 CI/管道集成）
+soulhub search writer --json
 ```
 
 ### 安装 Agent
 
 CLI 会自动识别目标是单 Agent 还是多 Agent 团队，无需手动区分。
 
-**默认行为：安装为 Worker Agent，自动安装到所有检测到的 claw 目录。**
+**默认行为：交互式安装。** CLI 会提示用户选择安装角色（主 Agent / Worker Agent）以及目标 claw 目录（支持多选）。通过命令行参数可跳过交互，实现完全非交互式安装。
 
 **从 Registry 安装：**
 
 ```bash
-# 安装单 Agent（默认为 worker，安装到所有检测到的 claw）
+# 交互式安装（会提示选择角色和 claw 目录）
 soulhub install writer-wechat
 
-# 安装为主 Agent
-soulhub install writer-wechat --main
+# 指定角色，仍交互选择 claw 目录
+soulhub install writer-wechat --role main
+soulhub install writer-wechat --role worker
+
+# 指定 claw 类型，仍交互选择角色
+soulhub install writer-wechat --claw-type LightClaw
+
+# 完全非交互式安装
+soulhub install writer-wechat --role worker --claw-type OpenClaw
+
+# 完全非交互式安装（主 Agent，-y 跳过确认）
+soulhub install writer-wechat --role main --claw-type OpenClaw -y
 
 # 安装多 Agent 团队（调度 Agent + 工作 Agent）
 soulhub install dev-squad
@@ -89,15 +135,27 @@ soulhub install --from https://example.com/agent-team.zip
 ```bash
 # 安装到自定义目录（不依赖 OpenClaw/LightClaw 环境）
 soulhub install writer-wechat --dir ./my-agents
+```
+
+### 查看 Agent 详情
 
-# 指定 claw 类型（只安装到该 claw）
-soulhub install writer-wechat --clawtype LightClaw
+```bash
+soulhub info writer-xiaohongshu
+
+# 查看 IDENTITY.md 和 SOUL.md 内容
+soulhub info writer-xiaohongshu --identity --soul
+
+# JSON 格式输出
+soulhub info writer-xiaohongshu --json
 ```
 
 ### 列出已安装的 Agent
 
 ```bash
 soulhub list
+
+# JSON 格式输出
+soulhub list --json
 ```
 
 ### 更新 Agent
@@ -109,28 +167,81 @@ soulhub update ops-assistant # 更新指定 Agent
 
 ### 卸载 Agent
 
+卸载时，如果存在相关备份记录，CLI 会提示用户确认，因为卸载操作会同时删除该 Agent 的所有备份文件，删除后将无法回滚。使用 `-y` 参数可跳过确认。
+
 ```bash
 soulhub uninstall ops-assistant
+
+# 跳过确认提示
+soulhub uninstall ops-assistant -y
+```
+
+使用 `--keep-files` 参数可保留 workspace 文件，仅从安装记录中移除：
+
+```bash
+soulhub uninstall ops-assistant --keep-files
+```
+
+### 回滚安装
+
+每次安装操作都会自动创建备份记录，支持回滚到安装前的状态。
+
+```bash
+# 交互式选择：展示所有备份记录，选择要回滚的项
+soulhub rollback
+
+# 查看所有可用的回滚记录
+soulhub rollback --list
+
+# 非交互式：回滚最近一次安装
+soulhub rollback --last 1
+
+# 非交互式：回滚最近一次安装（跳过确认）
+soulhub rollback --last 1 -y
+
+# 非交互式：回滚倒数第 2 次安装
+soulhub rollback --last 2
+
+# 按 ID 回滚到指定记录
+soulhub rollback --id <record-id>
 ```
 
 ## 安装行为说明
 
+### 交互式安装流程
+
+未指定 `--role` 和 `--claw-type` 参数时，CLI 进入交互式安装：
+
+1. 展示 Agent 基本信息（名称、版本、描述、分类、标签）
+2. 提示选择安装角色：**Main Agent** 或 **Worker Agent**
+3. 安装为 Main Agent 时，警告将覆盖当前 workspace 内容（人格文件会被替换，记忆不受影响），需用户确认（或使用 `-y` 跳过）
+4. 提示多选目标 claw 目录（OpenClaw / LightClaw），可同时安装到多个 claw
+5. 执行安装、注册、重启
+
 ### 单 Agent 安装
 
-- **默认安装为 Worker Agent**（子 agent），部署到 `workspace-<agentId>/` 目录
-- 使用 `--main` 参数可安装为主 Agent，部署到 `workspace/` 目录
-- **自动安装到所有检测到的 claw 目录**（OpenClaw / LightClaw），使用 `--clawtype` 可指定单个 claw
-- 如果目标目录已存在，CLI 会**自动备份**（复制到 `agentbackup/`）
+- 安装为 **Worker Agent** 时，部署到 `workspace-<agentId>/` 目录
+- 安装为 **Main Agent** 时，部署到 `workspace/` 目录，会覆盖已有人格文件
+- 安装前自动备份已有内容到 `~/.soulhub/backups/<claw>/`（按 claw 类型分目录存储）
 - 仅覆盖 `IDENTITY.md`、`SOUL.md` 等灵魂文件，不影响 workspace 中的其他运行时文件
-- 安装完成后自动重启 OpenClaw Gateway；若重启失败会提示手动重启
+- 安装完成后自动重启 OpenClaw/LightClaw Gateway；若重启失败会提示手动重启
 
 ### 多 Agent 团队安装
 
 - **调度 Agent（Dispatcher）** 作为主 Agent 安装到 `workspace/` 目录
 - **工作 Agent（Worker）** 安装到各自的 `workspace-<agentId>/` 目录
+- 安装前自动备份存量子 Agent（mv 方式移走已有 worker 目录）
 - 自动配置多 Agent 之间的通信
 - Worker Agent 自动注册到 claw 配置中
-- 安装完成后自动重启 OpenClaw Gateway
+- 安装完成后自动重启 OpenClaw/LightClaw Gateway
+
+### 备份与回滚
+
+- 备份文件存储在 `~/.soulhub/backups/<claw>/` 目录下，按 claw 类型（如 `openclaw`、`lightclaw`）分目录管理
+- 备份清单记录在 `~/.soulhub/backup-manifest.json` 中
+- 每次安装都会自动创建备份记录，包含 agent 文件和 claw 配置快照
+- 回滚时自动恢复备份文件和 claw 配置，并重启 Gateway
+- 卸载 Agent 时会同时清理相关备份记录和备份文件
 
 ## 配置
 
@@ -148,11 +259,12 @@ export SOULHUB_REGISTRY_URL=https://your-registry.example.com
 
 CLI 按以下优先级查找 claw 安装目录：
 
-1. `--clawtype` 命令行参数（指定时只安装到该 claw）
-2. `OPENCLAW_HOME` / `LIGHTCLAW_HOME` 环境变量
-3. 默认路径 `~/.openclaw`、`~/.lightclaw`
+1. `--claw-type` 命令行参数（指定时只安装到该 claw）
+2. `--dir` 命令行参数（直接指定目标目录，不依赖 claw 环境）
+3. `OPENCLAW_HOME` / `LIGHTCLAW_HOME` 环境变量
+4. 默认路径 `~/.openclaw`、`~/.lightclaw`
 
-未指定 `--clawtype` 时，CLI 会检测所有可用的 claw 目录并全部安装。
+未指定 `--claw-type` 或 `--dir` 时，CLI 会检测所有可用的 claw 目录，多个时交互式多选。
 
 ## 环境要求
 

package/dist/index.cjs

@@ -966,7 +966,7 @@ var require_command = __commonJS({
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
     var path5 = require("path");
-    var fs7 = require("fs");
+    var fs8 = require("fs");
     var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1899,10 +1899,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path5.resolve(baseDir, baseName);
-          if (fs7.existsSync(localBin)) return localBin;
+          if (fs8.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path5.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs7.existsSync(`${localBin}${ext}`)
+            (ext) => fs8.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1914,7 +1914,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs7.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs8.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -19165,6 +19165,11 @@ function recordInstall(name, version, workspace) {
   saveConfig(config);
   logger.debug(`Recorded install`, { name, version, workspace });
 }
+function removeInstallRecord(name) {
+  const config = loadConfig();
+  config.installed = config.installed.filter((a) => a.name !== name);
+  saveConfig(config);
+}
 function getWorkspaceDir(clawDir, agentName) {
   return import_node_path11.default.join(clawDir, `workspace-${agentName}`);
 }
@@ -19301,6 +19306,11 @@ function detectPackageKind(dir) {
   }
   return "unknown";
 }
+function getBackupBaseDir(clawDir) {
+  const home = process.env.HOME || "~";
+  const brand = detectClawBrand(clawDir).toLowerCase();
+  return import_node_path11.default.join(home, ".soulhub", "backups", brand);
+}
 function backupAgentWorkspace(workspaceDir) {
   if (!import_node_fs8.default.existsSync(workspaceDir)) {
     return null;
@@ -19310,7 +19320,7 @@ function backupAgentWorkspace(workspaceDir) {
     return null;
   }
   const clawDir = import_node_path11.default.dirname(workspaceDir);
-  const backupBaseDir = import_node_path11.default.join(clawDir, "agentbackup");
+  const backupBaseDir = getBackupBaseDir(clawDir);
   if (!import_node_fs8.default.existsSync(backupBaseDir)) {
     import_node_fs8.default.mkdirSync(backupBaseDir, { recursive: true });
   }
@@ -19333,7 +19343,7 @@ function moveBackupAgentWorkspace(workspaceDir) {
     return null;
   }
   const clawDir = import_node_path11.default.dirname(workspaceDir);
-  const backupBaseDir = import_node_path11.default.join(clawDir, "agentbackup");
+  const backupBaseDir = getBackupBaseDir(clawDir);
   if (!import_node_fs8.default.existsSync(backupBaseDir)) {
     import_node_fs8.default.mkdirSync(backupBaseDir, { recursive: true });
   }
@@ -19343,7 +19353,12 @@ function moveBackupAgentWorkspace(workspaceDir) {
     const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
     backupDir = import_node_path11.default.join(backupBaseDir, `${dirName}-${timestamp2}`);
   }
-  import_node_fs8.default.renameSync(workspaceDir, backupDir);
+  try {
+    import_node_fs8.default.renameSync(workspaceDir, backupDir);
+  } catch {
+    import_node_fs8.default.cpSync(workspaceDir, backupDir, { recursive: true });
+    import_node_fs8.default.rmSync(workspaceDir, { recursive: true, force: true });
+  }
   logger.info(`Workspace moved to backup`, { from: workspaceDir, to: backupDir });
   return backupDir;
 }
@@ -19432,6 +19447,106 @@ function commitBackupRecord(record) {
   saveBackupManifest(manifest);
   logger.info(`Backup record saved`, { id: record.id, items: record.items.length, workers: record.installedWorkerIds.length });
 }
+async function promptSelectRole() {
+  console.log();
+  console.log("  ? Install as:");
+  console.log();
+  console.log("    1) \u{1F477}  Worker agent  (\u5B50Agent\uFF0C\u5B89\u88C5\u5230 workspace-<name>/ \u76EE\u5F55)");
+  console.log("    2) \u{1F451}  Main agent    (\u4E3BAgent\uFF0C\u5B89\u88C5\u5230 workspace/ \u76EE\u5F55)");
+  console.log();
+  const rl = import_node_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question("  Please select (1-2) [1]: ", (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (trimmed === "" || trimmed === "1") {
+        resolve("worker");
+      } else if (trimmed === "2") {
+        resolve("main");
+      } else {
+        console.log("  Invalid selection, operation cancelled.");
+        resolve(null);
+      }
+    });
+  });
+}
+async function promptMultiSelectClawDirs() {
+  const dirs = findAllClawDirs();
+  if (dirs.length === 0) {
+    return [];
+  }
+  if (dirs.length === 1) {
+    const brand = detectClawBrand(dirs[0]);
+    console.log();
+    console.log(`  \u2714 Detected ${brand}: ${dirs[0]}`);
+    return dirs;
+  }
+  console.log();
+  console.log("  ? Select target Claw installations (multiple allowed):");
+  console.log();
+  dirs.forEach((dir, index) => {
+    const brand = detectClawBrand(dir);
+    console.log(`    ${index + 1}) ${brand}  ${dir}`);
+  });
+  console.log();
+  const rl = import_node_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    const allNums = dirs.map((_2, i) => String(i + 1)).join(",");
+    rl.question(`  Enter numbers separated by comma (e.g. 1,2) [${allNums}]: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim();
+      if (trimmed === "") {
+        resolve(dirs);
+        return;
+      }
+      const parts = trimmed.split(",").map((s3) => s3.trim());
+      const selected = [];
+      for (const part of parts) {
+        const idx = parseInt(part, 10);
+        if (idx >= 1 && idx <= dirs.length) {
+          const dir = dirs[idx - 1];
+          if (!selected.includes(dir)) {
+            selected.push(dir);
+          }
+        } else {
+          console.log(`  Invalid selection: ${part}, operation cancelled.`);
+          resolve([]);
+          return;
+        }
+      }
+      if (selected.length === 0) {
+        console.log("  No claw selected, operation cancelled.");
+      }
+      resolve(selected);
+    });
+  });
+}
+async function promptConfirm(message, defaultYes = true) {
+  const rl = import_node_readline.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const hint = defaultYes ? "Y/n" : "y/N";
+  return new Promise((resolve) => {
+    rl.question(`  ${message} (${hint}) `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "") {
+        resolve(defaultYes);
+      } else if (trimmed === "y" || trimmed === "yes") {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
 var CATEGORY_LABELS = {
   "self-media": "Self Media",
   development: "Development",
@@ -19538,7 +19653,7 @@ function restartOpenClawGateway(clawDir) {
 }
 
 // src/commands/search.ts
-var searchCommand = new Command("search").description("Search for agents in the SoulHub registry").argument("[query]", "Search query (matches name, description, tags)").option("-c, --category <category>", "Filter by category").option("-l, --limit <number>", "Max results to show", "20").action(async (query, options) => {
+var searchCommand = new Command("search").description("Search for agents in the SoulHub registry").argument("[query]", "Search query (matches name, description, tags)").option("-c, --category <category>", "Filter by category").option("-n, --limit <number>", "Max results to show", "20").option("--json", "Output results in JSON format").action(async (query, options) => {
   try {
     const index = await fetchIndex();
     let agents = index.agents;
@@ -19556,14 +19671,30 @@ var searchCommand = new Command("search").description("Search for agents in the
     const limit = parseInt(options.limit, 10);
     const shown = agents.slice(0, limit);
     if (shown.length === 0) {
-      console.log(source_default.yellow("No agents found matching your query."));
-      if (query) {
-        console.log(
-          source_default.dim(`  Try: soulhub search (without query to list all)`)
-        );
+      if (options.json) {
+        console.log(JSON.stringify([], null, 2));
+      } else {
+        console.log(source_default.yellow("No agents found matching your query."));
+        if (query) {
+          console.log(
+            source_default.dim(`  Try: soulhub search (without query to list all)`)
+          );
+        }
       }
       return;
     }
+    if (options.json) {
+      const jsonOutput = shown.map((a) => ({
+        name: a.name,
+        displayName: a.displayName,
+        version: a.version,
+        description: a.description,
+        category: a.category,
+        tags: a.tags
+      }));
+      console.log(JSON.stringify(jsonOutput, null, 2));
+      return;
+    }
     console.log(
       source_default.bold(`
   Found ${agents.length} agent(s):
@@ -19604,7 +19735,7 @@ var searchCommand = new Command("search").description("Search for agents in the
 });
 
 // src/commands/info.ts
-var infoCommand = new Command("info").description("Show details of an agent (identity, soul, skills, etc.)").argument("<name>", "Agent name").option("--identity", "Show IDENTITY.md content").option("--soul", "Show SOUL.md content").action(async (name, options) => {
+var infoCommand = new Command("info").description("Show details of an agent (identity, soul, skills, etc.)").argument("<name>", "Agent name").option("--identity", "Show IDENTITY.md content").option("--soul", "Show SOUL.md content").option("--json", "Output results in JSON format").action(async (name, options) => {
   try {
     const index = await fetchIndex();
     const agent = index.agents.find((a) => a.name === name);
@@ -19616,6 +19747,22 @@ var infoCommand = new Command("info").description("Show details of an agent (ide
       process.exit(1);
     }
     const category = CATEGORY_LABELS[agent.category] || agent.category;
+    if (options.json) {
+      const jsonOutput = {
+        name: agent.name,
+        displayName: agent.displayName,
+        version: agent.version,
+        description: agent.description,
+        category: agent.category,
+        author: agent.author,
+        tags: agent.tags,
+        minClawVersion: agent.minClawVersion,
+        downloads: agent.downloads,
+        files: agent.files
+      };
+      console.log(JSON.stringify(jsonOutput, null, 2));
+      return;
+    }
     console.log();
     console.log(source_default.bold.cyan(`  ${agent.displayName}`));
     console.log(source_default.dim(`  ${agent.name} v${agent.version}`));
@@ -19644,7 +19791,7 @@ var infoCommand = new Command("info").description("Show details of an agent (ide
       console.log(`    ${fileName} ${source_default.dim(`(${sizeStr})`)}`);
     }
     if (options.identity || options.soul) {
-      const fs7 = await import("fs");
+      const fs8 = await import("fs");
       const pkgDir = await downloadAgentPackage(name, agent.version);
       try {
         if (options.identity) {
@@ -19652,8 +19799,8 @@ var infoCommand = new Command("info").description("Show details of an agent (ide
           console.log(source_default.bold("  \u2500\u2500 IDENTITY.md \u2500\u2500"));
           console.log();
           const identityPath = (await import("path")).default.join(pkgDir, "IDENTITY.md");
-          if (fs7.default.existsSync(identityPath)) {
-            const content = fs7.default.readFileSync(identityPath, "utf-8");
+          if (fs8.default.existsSync(identityPath)) {
+            const content = fs8.default.readFileSync(identityPath, "utf-8");
             console.log(
               content.split("\n").map((l) => `  ${l}`).join("\n")
             );
@@ -19666,8 +19813,8 @@ var infoCommand = new Command("info").description("Show details of an agent (ide
           console.log(source_default.bold("  \u2500\u2500 SOUL.md \u2500\u2500"));
           console.log();
           const soulPath = (await import("path")).default.join(pkgDir, "SOUL.md");
-          if (fs7.default.existsSync(soulPath)) {
-            const content = fs7.default.readFileSync(soulPath, "utf-8");
+          if (fs8.default.existsSync(soulPath)) {
+            const content = fs8.default.readFileSync(soulPath, "utf-8");
             console.log(
               content.split("\n").map((l) => `  ${l}`).join("\n")
             );
@@ -19676,7 +19823,7 @@ var infoCommand = new Command("info").description("Show details of an agent (ide
           }
         }
       } finally {
-        fs7.default.rmSync(pkgDir, { recursive: true, force: true });
+        fs8.default.rmSync(pkgDir, { recursive: true, force: true });
       }
     }
     console.log();
@@ -19778,27 +19925,39 @@ function resolveAllClawDirs(clawDir) {
   }
   return findAllClawDirs();
 }
-var installCommand = new Command("install").description("Install an agent or team from the SoulHub registry (default: as worker, installs to all detected claws)").argument("[name]", "Agent or team name to install").option("--from <source>", "Install from a local directory, ZIP file, or URL").option("--main", "Install as main agent").option(
+var installCommand = new Command("install").description("Install an agent or team from the SoulHub registry").argument("[name]", "Agent or team name to install").option("--from <source>", "Install from a local directory, ZIP file, or URL").option("-r, --role <role>", "Install role: main or worker (skip role selection prompt)").option(
   "--dir <path>",
   "Target directory (defaults to OpenClaw/LightClaw workspace)"
 ).option(
-  "--clawtype <type>",
+  "--claw-type <type>",
   "Specify claw type: OpenClaw or LightClaw (case-insensitive)"
-).action(async (name, options) => {
+).option("-y, --yes", "Skip all confirmation prompts (auto-confirm)").action(async (name, options) => {
   try {
-    const asMain = !!options.main;
+    const roleExplicit = !!options.role;
+    const clawExplicit = !!options.clawType || !!options.dir;
+    const skipConfirm = !!options.yes;
+    if (options.role && !["main", "worker"].includes(options.role.toLowerCase())) {
+      console.error(source_default.red(`Invalid role: "${options.role}". Must be "main" or "worker".`));
+      process.exit(1);
+    }
     if (options.from) {
-      await installFromSource(options.from, options.dir, options.clawtype, asMain);
+      const asMain = await resolveRole(roleExplicit ? options.role.toLowerCase() === "main" : void 0);
+      if (asMain === null) return;
+      await installFromSource(options.from, options.dir, options.clawType, asMain, clawExplicit, skipConfirm);
     } else if (name) {
-      await installFromRegistry(name, options.dir, options.clawtype, asMain);
+      const resolvedRole = roleExplicit ? options.role.toLowerCase() === "main" : void 0;
+      await installFromRegistry(name, options.dir, options.clawType, resolvedRole, clawExplicit, skipConfirm);
     } else {
       console.error(source_default.red("Please specify an agent or team name, or use --from to install from a local source."));
-      console.log(source_default.dim("  Examples:"));
-      console.log(source_default.dim("    soulhub install writer-wechat            # Install as worker to all detected claws"));
-      console.log(source_default.dim("    soulhub install writer-wechat --main     # Install as main agent"));
-      console.log(source_default.dim("    soulhub install dev-squad                # Install a team from registry"));
-      console.log(source_default.dim("    soulhub install --from ./agent-team/     # Install from local directory"));
-      console.log(source_default.dim("    soulhub install writer-wechat --clawtype LightClaw  # Install to specific claw"));
+      console.log();
+      console.log(source_default.dim("  Usage:"));
+      console.log(source_default.dim("    soulhub install <name>                                 # Interactive: select role & claw"));
+      console.log(source_default.dim("    soulhub install <name> --role main                     # As main agent, interactive claw selection"));
+      console.log(source_default.dim("    soulhub install <name> --role worker                   # As worker agent, interactive claw selection"));
+      console.log(source_default.dim("    soulhub install <name> --claw-type LightClaw            # Interactive role, install to specific claw"));
+      console.log(source_default.dim("    soulhub install <name> --role worker --claw-type OpenClaw  # Fully non-interactive"));
+      console.log(source_default.dim("    soulhub install <name> --role main --claw-type OpenClaw -y  # Non-interactive, skip confirmation"));
+      console.log(source_default.dim("    soulhub install --from ./agent-dir/                     # Install from local directory"));
       process.exit(1);
     }
   } catch (error) {
@@ -19810,15 +19969,60 @@ var installCommand = new Command("install").description("Install an agent or tea
     process.exit(1);
   }
 });
-async function installFromRegistry(name, targetDir, clawDir, asMain) {
+async function resolveRole(explicitMain) {
+  if (explicitMain !== void 0) {
+    return explicitMain;
+  }
+  const role = await promptSelectRole();
+  if (role === null) return null;
+  return role === "main";
+}
+async function resolveClawDirsInteractive(clawDir, clawExplicit) {
+  if (clawDir) {
+    return resolveAllClawDirs(clawDir);
+  }
+  if (clawExplicit) {
+    return [];
+  }
+  return promptMultiSelectClawDirs();
+}
+async function installFromRegistry(name, targetDir, clawDir, asMain, clawExplicit, skipConfirm = false) {
   const spinner = createSpinner(`Checking registry for ${source_default.cyan(name)}...`).start();
   const index = await fetchIndex();
   const agent = index.agents.find((a) => a.name === name);
   const recipe = index.recipes.find((r) => r.name === name);
   if (agent && !recipe) {
     spinner.stop();
-    logger.info(`Installing single agent from registry: ${name}, asMain=${asMain}`);
-    await installSingleAgent(name, targetDir, clawDir, asMain);
+    printAgentInfo(agent);
+    const resolvedMain = await resolveRole(asMain);
+    if (resolvedMain === null) return;
+    if (resolvedMain) {
+      console.log();
+      console.log(source_default.yellow("  \u26A0  Installing as main agent will overwrite the current workspace/ content."));
+      console.log(source_default.yellow("     The existing persona (IDENTITY.md, SOUL.md, etc.) will be replaced."));
+      console.log(source_default.yellow("     Memory and conversation history will NOT be affected."));
+      console.log();
+      if (!skipConfirm) {
+        const confirmed = await promptConfirm("Continue?", true);
+        if (!confirmed) {
+          console.log(source_default.dim("  Installation cancelled."));
+          return;
+        }
+      } else {
+        console.log(source_default.dim("  Auto-confirmed with --yes flag."));
+      }
+    }
+    let resolvedClawDirs;
+    if (!targetDir) {
+      resolvedClawDirs = await resolveClawDirsInteractive(clawDir, clawExplicit);
+      if (resolvedClawDirs.length === 0) {
+        console.log(source_default.red("\n  OpenClaw/LightClaw workspace directory not found."));
+        printOpenClawInstallHelp();
+        return;
+      }
+    }
+    logger.info(`Installing single agent from registry: ${name}, asMain=${resolvedMain}`);
+    await installSingleAgent(name, targetDir, clawDir, resolvedMain, resolvedClawDirs);
   } else if (recipe) {
     spinner.stop();
     logger.info(`Installing team recipe from registry: ${name}`);
@@ -19829,12 +20033,25 @@ async function installFromRegistry(name, targetDir, clawDir, asMain) {
     console.log(source_default.dim("  Use 'soulhub search' to find available agents and teams."));
   }
 }
-async function installSingleAgent(name, targetDir, clawDir, asMain = false) {
+function printAgentInfo(agent) {
+  console.log();
+  console.log(source_default.bold(`  \u{1F4E6} ${agent.displayName}`), source_default.dim(`v${agent.version}`));
+  if (agent.description) {
+    console.log(source_default.dim(`     ${agent.description}`));
+  }
+  if (agent.category) {
+    console.log(source_default.dim(`     Category: ${agent.category}`));
+  }
+  if (agent.tags && agent.tags.length > 0) {
+    console.log(source_default.dim(`     Tags: ${agent.tags.join(", ")}`));
+  }
+}
+async function installSingleAgent(name, targetDir, clawDir, asMain = false, preResolvedClawDirs) {
   if (targetDir) {
     await installSingleAgentToClaw(name, null, targetDir, asMain);
     return;
   }
-  const allClawDirs = resolveAllClawDirs(clawDir);
+  const allClawDirs = preResolvedClawDirs || resolveAllClawDirs(clawDir);
   if (allClawDirs.length === 0) {
     console.log(source_default.red("OpenClaw/LightClaw workspace directory not found."));
     printOpenClawInstallHelp();
@@ -20064,7 +20281,8 @@ async function installRecipeFromRegistry(name, recipe, targetDir, clawDir) {
     await tryRestartGateway(resolvedClawDir);
   }
 }
-async function installFromSource(source, targetDir, clawDir, asMain) {
+async function installFromSource(source, targetDir, clawDir, asMain, clawExplicit, skipConfirm = false) {
+  if (asMain === null) return;
   const spinner = createSpinner("Analyzing package...").start();
   let packageDir;
   let tempDir = null;
@@ -20118,7 +20336,7 @@ async function installFromSource(source, targetDir, clawDir, asMain) {
   spinner.text = `Detected package type: ${source_default.blue(kind)}`;
   if (kind === "agent") {
     spinner.stop();
-    await installSingleAgentFromDir(packageDir, targetDir, clawDir, asMain);
+    await installSingleAgentFromDir(packageDir, targetDir, clawDir, asMain, clawExplicit, skipConfirm);
   } else if (kind === "team") {
     spinner.stop();
     await installTeamFromDir(packageDir, targetDir, clawDir);
@@ -20130,14 +20348,30 @@ async function installFromSource(source, targetDir, clawDir, asMain) {
     import_node_fs9.default.rmSync(tempDir, { recursive: true, force: true });
   }
 }
-async function installSingleAgentFromDir(packageDir, targetDir, clawDir, asMain = false) {
+async function installSingleAgentFromDir(packageDir, targetDir, clawDir, asMain = false, clawExplicit, skipConfirm = false) {
   const pkg = readSoulHubPackage(packageDir);
   const agentName = pkg?.name || import_node_path12.default.basename(packageDir);
+  if (asMain) {
+    console.log();
+    console.log(source_default.yellow("  \u26A0  Installing as main agent will overwrite the current workspace/ content."));
+    console.log(source_default.yellow("     The existing persona (IDENTITY.md, SOUL.md, etc.) will be replaced."));
+    console.log(source_default.yellow("     Memory and conversation history will NOT be affected."));
+    console.log();
+    if (!skipConfirm) {
+      const confirmed = await promptConfirm("Continue?", true);
+      if (!confirmed) {
+        console.log(source_default.dim("  Installation cancelled."));
+        return;
+      }
+    } else {
+      console.log(source_default.dim("  Auto-confirmed with --yes flag."));
+    }
+  }
   if (targetDir) {
     await installSingleAgentFromDirToClaw(packageDir, agentName, pkg, null, targetDir, asMain);
     return;
   }
-  const allClawDirs = resolveAllClawDirs(clawDir);
+  const allClawDirs = await resolveClawDirsInteractive(clawDir, clawExplicit);
   if (allClawDirs.length === 0) {
     console.log(source_default.red("OpenClaw/LightClaw workspace directory not found."));
     printOpenClawInstallHelp();
@@ -20418,7 +20652,7 @@ async function extractZipToDir(zip, targetDir) {
 }
 function printOpenClawInstallHelp() {
   console.log(source_default.dim("  Please install OpenClaw or LightClaw first, or use one of the following options:"));
-  console.log(source_default.dim("  --clawtype <type>            Specify claw type: OpenClaw or LightClaw"));
+  console.log(source_default.dim("  --claw-type <type>           Specify claw type: OpenClaw or LightClaw"));
   console.log(source_default.dim("  --dir <path>                 Specify agent target directory directly"));
   console.log(source_default.dim("  OPENCLAW_HOME=<path>         Set environment variable (for OpenClaw)"));
   console.log(source_default.dim("  LIGHTCLAW_HOME=<path>        Set environment variable (for LightClaw)"));
@@ -20451,17 +20685,31 @@ async function tryRestartGateway(clawDir) {
 }
 
 // src/commands/list.ts
-var listCommand = new Command("list").description("List installed agents").alias("ls").action(async () => {
+var listCommand = new Command("list").description("List installed agents").alias("ls").option("--json", "Output results in JSON format").action(async (options) => {
   try {
     const config = loadConfig();
     if (config.installed.length === 0) {
-      console.log(source_default.yellow("\n  No agents installed yet.\n"));
-      console.log(
-        source_default.dim("  Install one: soulhub install <name>")
-      );
-      console.log(
-        source_default.dim("  Browse all:  soulhub search\n")
-      );
+      if (options.json) {
+        console.log(JSON.stringify([], null, 2));
+      } else {
+        console.log(source_default.yellow("\n  No agents installed yet.\n"));
+        console.log(
+          source_default.dim("  Install one: soulhub install <name>")
+        );
+        console.log(
+          source_default.dim("  Browse all:  soulhub search\n")
+        );
+      }
+      return;
+    }
+    if (options.json) {
+      const jsonOutput = config.installed.map((a) => ({
+        name: a.name,
+        version: a.version,
+        installedAt: a.installedAt,
+        workspace: a.workspace
+      }));
+      console.log(JSON.stringify(jsonOutput, null, 2));
       return;
     }
     console.log(
@@ -20519,6 +20767,19 @@ var updateCommand = new Command("update").description("Update installed agents t
       }
       spinner.text = `Updating ${source_default.cyan(installed.name)} (${installed.version} \u2192 ${remote.version})...`;
       const workspaceDir = installed.workspace;
+      const backupDir = backupAgentWorkspace(workspaceDir);
+      if (backupDir) {
+        const backupRecord = createBackupRecord("single-agent", installed.name, workspaceDir);
+        addBackupItem(backupRecord, {
+          originalPath: workspaceDir,
+          backupPath: backupDir,
+          method: "cp",
+          role: "worker",
+          agentId: installed.name
+        });
+        commitBackupRecord(backupRecord);
+        logger.info(`Update backup created for ${installed.name}`, { backupDir });
+      }
       if (!import_node_fs10.default.existsSync(workspaceDir)) {
         import_node_fs10.default.mkdirSync(workspaceDir, { recursive: true });
       }
@@ -20547,20 +20808,109 @@ var updateCommand = new Command("update").description("Update installed agents t
   }
 });
 
-// src/commands/rollback.ts
+// src/commands/uninstall.ts
 var import_node_fs11 = __toESM(require("fs"), 1);
+var uninstallCommand = new Command("uninstall").description("Uninstall an agent template").alias("rm").argument("<name>", "Agent name to uninstall").option("--keep-files", "Remove from registry but keep workspace files").option("-y, --yes", "Skip all confirmation prompts (auto-confirm)").action(async (name, options) => {
+  try {
+    const config = loadConfig();
+    const installed = config.installed.find((a) => a.name === name);
+    if (!installed) {
+      console.error(
+        source_default.red(`
+  Agent "${name}" is not installed.
+`)
+      );
+      console.log(
+        source_default.dim("  Use 'soulhub list' to see installed agents.")
+      );
+      process.exit(1);
+    }
+    const spinner = createSpinner(
+      `Uninstalling ${source_default.cyan(name)}...`
+    ).start();
+    const manifest = loadBackupManifest();
+    const relatedRecords = manifest.records.filter((r) => r.packageName === name);
+    if (relatedRecords.length > 0) {
+      spinner.stop();
+      console.log(
+        source_default.yellow(`
+  \u26A0  Found ${relatedRecords.length} backup record(s) for "${name}".`)
+      );
+      console.log(
+        source_default.yellow(`     Uninstalling will also delete all related backup files.`)
+      );
+      console.log(
+        source_default.yellow(`     After deletion, you will NOT be able to rollback this agent.
+`)
+      );
+      if (!options.yes) {
+        const confirmed = await promptConfirm("Proceed with uninstall?");
+        if (!confirmed) {
+          console.log(source_default.dim("\n  Uninstall cancelled.\n"));
+          return;
+        }
+      } else {
+        console.log(source_default.dim("  Auto-confirmed with --yes flag."));
+      }
+      spinner.start(`Uninstalling ${source_default.cyan(name)}...`);
+    }
+    if (!options.keepFiles && import_node_fs11.default.existsSync(installed.workspace)) {
+      import_node_fs11.default.rmSync(installed.workspace, { recursive: true, force: true });
+      spinner.text = `Removed workspace: ${installed.workspace}`;
+    }
+    removeInstallRecord(name);
+    if (relatedRecords.length > 0) {
+      for (const record of relatedRecords) {
+        for (const item of record.items) {
+          if (import_node_fs11.default.existsSync(item.backupPath)) {
+            import_node_fs11.default.rmSync(item.backupPath, { recursive: true, force: true });
+            logger.info(`Cleaned backup file for uninstalled agent`, { backupPath: item.backupPath });
+          }
+        }
+      }
+      manifest.records = manifest.records.filter((r) => r.packageName !== name);
+      saveBackupManifest(manifest);
+      spinner.text = `Cleaned ${relatedRecords.length} backup record(s)`;
+      logger.info(`Cleaned ${relatedRecords.length} backup record(s) for ${name}`);
+    }
+    logger.info(`Agent uninstalled: ${name}`, { workspace: installed.workspace, keepFiles: !!options.keepFiles });
+    spinner.succeed(
+      `${source_default.cyan.bold(name)} uninstalled.`
+    );
+    if (options.keepFiles) {
+      console.log(
+        source_default.dim(`  Files kept at: ${installed.workspace}`)
+      );
+    }
+    console.log();
+  } catch (error) {
+    logger.errorObj("Uninstall command failed", error);
+    console.error(
+      source_default.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    console.error(source_default.dim(`  See logs: ${logger.getTodayLogFile()}`));
+    process.exit(1);
+  }
+});
+
+// src/commands/rollback.ts
+var import_node_fs12 = __toESM(require("fs"), 1);
 var import_node_path13 = __toESM(require("path"), 1);
-var rollbackCommand = new Command("rollback").description("Rollback to a previous agent installation state").option("--list", "List available rollback records").option("--id <id>", "Rollback to a specific backup record by ID").option(
-  "--clawtype <type>",
+var import_node_readline2 = __toESM(require("readline"), 1);
+var rollbackCommand = new Command("rollback").description("Rollback to a previous agent installation state").option("--list", "List available rollback records").option("--id <id>", "Rollback to a specific backup record by ID").option("--last <n>", "Rollback the Nth most recent installation (1 = latest, 2 = second latest, etc.)", parseInt).option(
+  "--claw-type <type>",
   "Specify claw type: OpenClaw or LightClaw (case-insensitive)"
-).action(async (options) => {
+).option("-y, --yes", "Skip all confirmation prompts (auto-confirm)").action(async (options) => {
   try {
+    const skipConfirm = !!options.yes;
     if (options.list) {
       listBackupRecords();
     } else if (options.id) {
-      await performRollback(options.id, options.clawtype);
+      await performRollback(options.id, options.clawType, skipConfirm);
+    } else if (options.last) {
+      await performRollbackByIndex(options.last, options.clawType, skipConfirm);
     } else {
-      await performRollback(void 0, options.clawtype);
+      await interactiveRollback(options.clawType);
     }
   } catch (error) {
     logger.errorObj("Rollback command failed", error);
@@ -20579,53 +20929,192 @@ function listBackupRecords() {
     return;
   }
   console.log(source_default.bold("\nAvailable rollback records:\n"));
+  printRecordTable(manifest.records);
+  console.log();
+  console.log(source_default.dim("  Usage:"));
+  console.log(source_default.dim("    soulhub rollback              # Interactive: select a record to rollback"));
+  console.log(source_default.dim("    soulhub rollback --last 1     # Rollback the latest installation"));
+  console.log(source_default.dim("    soulhub rollback --last 2     # Rollback the 2nd latest installation"));
+  console.log(source_default.dim("    soulhub rollback --id <id>    # Rollback to a specific record by ID"));
+  console.log();
+}
+function printRecordTable(records) {
   console.log(
     source_default.dim(
-      `  ${"ID".padEnd(20)} ${"Type".padEnd(20)} ${"Package".padEnd(20)} ${"Date".padEnd(22)} Items`
+      `  ${"#".padEnd(4)} ${"ID".padEnd(20)} ${"Type".padEnd(20)} ${"Package".padEnd(20)} ${"Claw".padEnd(14)} ${"Date".padEnd(22)} Items`
     )
   );
-  console.log(source_default.dim("  " + "\u2500".repeat(90)));
-  for (const record of manifest.records) {
+  console.log(source_default.dim("  " + "\u2500".repeat(108)));
+  records.forEach((record, index) => {
     const date = new Date(record.createdAt).toLocaleString();
     const typeLabel = formatInstallType(record.installType);
     const itemCount = record.items.length;
+    const clawBrand = detectClawBrandFromDir(record.clawDir);
     console.log(
-      `  ${source_default.cyan(record.id.padEnd(20))} ${typeLabel.padEnd(20)} ${source_default.white(record.packageName.padEnd(20))} ${source_default.dim(date.padEnd(22))} ${itemCount} backup(s)`
+      `  ${source_default.yellow(String(index + 1).padEnd(4))} ${source_default.cyan(record.id.padEnd(20))} ${typeLabel.padEnd(20)} ${source_default.white(record.packageName.padEnd(20))} ${source_default.dim(clawBrand.padEnd(14))} ${source_default.dim(date.padEnd(22))} ${itemCount} backup(s)`
     );
+  });
+}
+async function interactiveRollback(clawDir) {
+  const manifest = loadBackupManifest();
+  if (manifest.records.length === 0) {
+    console.log(source_default.yellow("No backup records found. Nothing to rollback."));
+    console.log(source_default.dim("  Backup records are created automatically when you install agents."));
+    return;
   }
+  console.log(source_default.bold("\n  Select a record to rollback:\n"));
+  printRecordTable(manifest.records);
   console.log();
-  console.log(source_default.dim("  Usage:"));
-  console.log(source_default.dim("    soulhub rollback              # Rollback last installation"));
-  console.log(source_default.dim("    soulhub rollback --id <id>    # Rollback to a specific record"));
+  const rl = import_node_readline2.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const selected = await new Promise((resolve) => {
+    rl.question(`  Enter number to rollback (1-${manifest.records.length}), or 'q' to cancel: `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "q" || trimmed === "quit" || trimmed === "") {
+        resolve(null);
+        return;
+      }
+      const idx = parseInt(trimmed, 10);
+      if (idx >= 1 && idx <= manifest.records.length) {
+        resolve(idx);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+  if (selected === null) {
+    console.log(source_default.dim("  Rollback cancelled."));
+    return;
+  }
+  const record = manifest.records[selected - 1];
   console.log();
+  console.log(source_default.dim(`  Selected: ${source_default.cyan(record.id)} (${record.packageName})`));
+  printRollbackDetails(record);
+  const confirmed = await promptConfirmRollback();
+  if (!confirmed) {
+    console.log(source_default.dim("  Rollback cancelled."));
+    return;
+  }
+  await executeRollback(record, clawDir);
 }
-async function performRollback(recordId, clawDir) {
+async function performRollbackByIndex(n, clawDir, skipConfirm = false) {
   const manifest = loadBackupManifest();
   if (manifest.records.length === 0) {
     console.log(source_default.yellow("No backup records found. Nothing to rollback."));
     return;
   }
-  let record;
-  if (recordId) {
-    record = manifest.records.find((r) => r.id === recordId);
-    if (!record) {
-      console.error(source_default.red(`Backup record "${recordId}" not found.`));
-      console.log(source_default.dim("  Use 'soulhub rollback --list' to see available records."));
+  if (n < 1 || n > manifest.records.length) {
+    console.error(source_default.red(`Invalid index: ${n}. Available range: 1-${manifest.records.length}`));
+    console.log(source_default.dim("  Use 'soulhub rollback --list' to see all available records."));
+    return;
+  }
+  const record = manifest.records[n - 1];
+  console.log(
+    source_default.dim(
+      `
+  Rolling back #${n}: ${source_default.cyan(record.id)} (${record.packageName})`
+    )
+  );
+  printRollbackDetails(record);
+  if (!skipConfirm) {
+    const rl2 = import_node_readline2.default.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const confirmed = await new Promise((resolve) => {
+      rl2.question(`  ${source_default.yellow("\u26A0")} Proceed with rollback? (Y/n) `, (answer) => {
+        rl2.close();
+        const trimmed = answer.trim().toLowerCase();
+        resolve(trimmed === "" || trimmed === "y" || trimmed === "yes");
+      });
+    });
+    if (!confirmed) {
+      console.log(source_default.dim("  Rollback cancelled."));
       return;
     }
   } else {
-    record = manifest.records[0];
-    console.log(
-      source_default.dim(
-        `Rolling back last installation: ${source_default.cyan(record.id)} (${record.packageName})`
-      )
-    );
+    console.log(source_default.dim("  Auto-confirmed with --yes flag."));
+  }
+  await executeRollback(record, clawDir);
+}
+async function performRollback(recordId, clawDir, skipConfirm = false) {
+  const manifest = loadBackupManifest();
+  if (manifest.records.length === 0) {
+    console.log(source_default.yellow("No backup records found. Nothing to rollback."));
+    return;
   }
+  const record = manifest.records.find((r) => r.id === recordId);
+  if (!record) {
+    console.error(source_default.red(`Backup record "${recordId}" not found.`));
+    console.log(source_default.dim("  Use 'soulhub rollback --list' to see available records."));
+    return;
+  }
+  console.log(
+    source_default.dim(
+      `
+  Rolling back: ${source_default.cyan(record.id)} (${record.packageName})`
+    )
+  );
+  printRollbackDetails(record);
+  if (!skipConfirm) {
+    const confirmed = await promptConfirmRollback();
+    if (!confirmed) {
+      console.log(source_default.dim("  Rollback cancelled."));
+      return;
+    }
+  } else {
+    console.log(source_default.dim("  Auto-confirmed with --yes flag."));
+  }
+  await executeRollback(record, clawDir);
+}
+function printRollbackDetails(record) {
+  console.log();
+  console.log(source_default.dim("  Rollback details:"));
+  console.log(source_default.dim(`    Package:    ${record.packageName}`));
+  console.log(source_default.dim(`    Type:       ${formatInstallType(record.installType)}`));
+  console.log(source_default.dim(`    Claw dir:   ${record.clawDir}`));
+  console.log(source_default.dim(`    Date:       ${new Date(record.createdAt).toLocaleString()}`));
+  if (record.items.length > 0) {
+    console.log(source_default.dim(`    Backups to restore:`));
+    for (const item of record.items) {
+      const methodLabel = item.method === "mv" ? "move back" : "copy back";
+      console.log(source_default.dim(`      - ${item.agentId} (${item.role}, ${methodLabel})`));
+    }
+  }
+  if (record.installedWorkerIds.length > 0) {
+    console.log(source_default.dim(`    Workers to remove: ${record.installedWorkerIds.join(", ")}`));
+  }
+  if (record.installedMainAgent) {
+    console.log(source_default.dim(`    Main agent to revert: ${record.installedMainAgent}`));
+  }
+  console.log();
+}
+async function promptConfirmRollback() {
+  const rl = import_node_readline2.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(`  ${source_default.yellow("\u26A0")} Proceed with rollback? (Y/n) `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === "" || trimmed === "y" || trimmed === "yes") {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+    });
+  });
+}
+async function executeRollback(record, clawDir) {
   const spinner = createSpinner(
     `Rolling back ${source_default.cyan(record.packageName)}...`
   ).start();
-  const resolvedClawDir = clawDir ? findOpenClawDir(clawDir) || record.clawDir : await promptSelectClawDir() || record.clawDir;
-  if (!resolvedClawDir || !import_node_fs11.default.existsSync(resolvedClawDir)) {
+  const resolvedClawDir = clawDir ? findOpenClawDir(clawDir) || record.clawDir : record.clawDir;
+  if (!resolvedClawDir || !import_node_fs12.default.existsSync(resolvedClawDir)) {
     spinner.fail(`OpenClaw/LightClaw directory not found: ${record.clawDir}`);
     return;
   }
@@ -20645,57 +21134,63 @@ async function performRollback(recordId, clawDir) {
     spinner.text = "Removing installed workers...";
     for (const workerId of record.installedWorkerIds) {
       const workerDir = getWorkspaceDir(resolvedClawDir, workerId);
-      if (import_node_fs11.default.existsSync(workerDir)) {
-        import_node_fs11.default.rmSync(workerDir, { recursive: true, force: true });
+      if (import_node_fs12.default.existsSync(workerDir)) {
+        import_node_fs12.default.rmSync(workerDir, { recursive: true, force: true });
         logger.info(`Removed installed worker directory`, { workerId, dir: workerDir });
       }
       const agentConfigDir = import_node_path13.default.join(resolvedClawDir, "agents", workerId);
-      if (import_node_fs11.default.existsSync(agentConfigDir)) {
-        import_node_fs11.default.rmSync(agentConfigDir, { recursive: true, force: true });
+      if (import_node_fs12.default.existsSync(agentConfigDir)) {
+        import_node_fs12.default.rmSync(agentConfigDir, { recursive: true, force: true });
       }
     }
   }
   if (record.installedMainAgent) {
     const mainWorkspace = getMainWorkspaceDir(resolvedClawDir);
     const hasMainBackup = record.items.some((item) => item.role === "main");
-    if (hasMainBackup && import_node_fs11.default.existsSync(mainWorkspace)) {
+    if (hasMainBackup && import_node_fs12.default.existsSync(mainWorkspace)) {
       spinner.text = "Cleaning current main workspace...";
-      const entries = import_node_fs11.default.readdirSync(mainWorkspace);
+      const entries = import_node_fs12.default.readdirSync(mainWorkspace);
       for (const entry of entries) {
-        import_node_fs11.default.rmSync(import_node_path13.default.join(mainWorkspace, entry), { recursive: true, force: true });
+        import_node_fs12.default.rmSync(import_node_path13.default.join(mainWorkspace, entry), { recursive: true, force: true });
       }
     }
   }
   let restoredCount = 0;
   for (const item of record.items) {
-    if (!import_node_fs11.default.existsSync(item.backupPath)) {
+    if (!import_node_fs12.default.existsSync(item.backupPath)) {
       logger.warn(`Backup path not found, skipping`, { backupPath: item.backupPath });
       console.log(source_default.yellow(`  \u26A0 Backup not found: ${item.backupPath}, skipping...`));
       continue;
     }
     spinner.text = `Restoring ${source_default.cyan(item.agentId)} (${item.role})...`;
     if (item.method === "mv") {
-      if (import_node_fs11.default.existsSync(item.originalPath)) {
-        import_node_fs11.default.rmSync(item.originalPath, { recursive: true, force: true });
+      if (import_node_fs12.default.existsSync(item.originalPath)) {
+        import_node_fs12.default.rmSync(item.originalPath, { recursive: true, force: true });
+      }
+      import_node_fs12.default.mkdirSync(import_node_path13.default.dirname(item.originalPath), { recursive: true });
+      try {
+        import_node_fs12.default.renameSync(item.backupPath, item.originalPath);
+      } catch {
+        import_node_fs12.default.cpSync(item.backupPath, item.originalPath, { recursive: true });
+        import_node_fs12.default.rmSync(item.backupPath, { recursive: true, force: true });
       }
-      import_node_fs11.default.mkdirSync(import_node_path13.default.dirname(item.originalPath), { recursive: true });
-      import_node_fs11.default.renameSync(item.backupPath, item.originalPath);
       logger.info(`Restored (mv back)`, { from: item.backupPath, to: item.originalPath });
     } else {
-      if (import_node_fs11.default.existsSync(item.originalPath)) {
-        const entries = import_node_fs11.default.readdirSync(item.originalPath);
+      if (import_node_fs12.default.existsSync(item.originalPath)) {
+        const entries = import_node_fs12.default.readdirSync(item.originalPath);
         for (const entry of entries) {
-          import_node_fs11.default.rmSync(import_node_path13.default.join(item.originalPath, entry), { recursive: true, force: true });
+          import_node_fs12.default.rmSync(import_node_path13.default.join(item.originalPath, entry), { recursive: true, force: true });
         }
       } else {
-        import_node_fs11.default.mkdirSync(item.originalPath, { recursive: true });
+        import_node_fs12.default.mkdirSync(item.originalPath, { recursive: true });
       }
-      import_node_fs11.default.cpSync(item.backupPath, item.originalPath, { recursive: true });
-      import_node_fs11.default.rmSync(item.backupPath, { recursive: true, force: true });
+      import_node_fs12.default.cpSync(item.backupPath, item.originalPath, { recursive: true });
+      import_node_fs12.default.rmSync(item.backupPath, { recursive: true, force: true });
       logger.info(`Restored (cp back)`, { from: item.backupPath, to: item.originalPath });
     }
     restoredCount++;
   }
+  const manifest = loadBackupManifest();
   manifest.records = manifest.records.filter((r) => r.id !== record.id);
   saveBackupManifest(manifest);
   spinner.succeed(
@@ -20729,16 +21224,23 @@ function formatInstallType(type2) {
       return type2;
   }
 }
+function detectClawBrandFromDir(clawDir) {
+  const dirName = import_node_path13.default.basename(clawDir).toLowerCase();
+  if (dirName.includes("lightclaw")) {
+    return "LightClaw";
+  }
+  return "OpenClaw";
+}
 
 // src/index.ts
 var program2 = new Command();
-program2.name("soulhub").description("SoulHub CLI - Discover, install and manage AI agent souls").version("1.0.21").option("--verbose", "Enable verbose debug logging").hook("preAction", () => {
+program2.name("soulhub").description("SoulHub CLI - Discover, install and manage AI agent souls").version("1.0.22").option("--verbose", "Enable verbose debug logging").hook("preAction", () => {
   const opts = program2.opts();
   const verbose = opts.verbose || process.env.SOULHUB_DEBUG === "1";
   logger.init(verbose);
   logger.info("CLI started", {
     args: process.argv.slice(2),
-    version: "1.0.21",
+    version: "1.0.22",
     node: process.version
   });
 });
@@ -20747,6 +21249,7 @@ program2.addCommand(infoCommand);
 program2.addCommand(installCommand);
 program2.addCommand(listCommand);
 program2.addCommand(updateCommand);
+program2.addCommand(uninstallCommand);
 program2.addCommand(rollbackCommand);
 program2.parse();
 /*! Bundled license information:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulhubcli",
-  "version": "1.0.21",
+  "version": "1.0.22",
   "description": "SoulHub CLI - Install and manage AI agent persona templates for OpenClaw",
   "type": "module",
   "bin": {