agor-live 0.9.2 → 0.9.3

package/dist/cli/commands/admin/add-to-worktree-group.d.ts

@@ -7,6 +7,8 @@ declare class AddToWorktreeGroup extends Command {
     static flags: {
         username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         group: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/add-to-worktree-group.js

@@ -1,11 +1,11 @@
 // src/commands/admin/add-to-worktree-group.ts
-import { execSync } from "child_process";
-import { UnixGroupCommands } from "@agor/core/unix";
+import { createAdminExecutor, UnixGroupCommands } from "@agor/core/unix";
 import { Command, Flags } from "@oclif/core";
 var AddToWorktreeGroup = class _AddToWorktreeGroup extends Command {
   static description = "Add a user to a worktree Unix group (admin only)";
   static examples = [
-    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447"
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447",
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447 --dry-run"
   ];
   static flags = {
     username: Flags.string({
@@ -17,19 +17,33 @@ var AddToWorktreeGroup = class _AddToWorktreeGroup extends Command {
       char: "g",
       description: "Unix group name (e.g., agor_wt_03b62447)",
       required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_AddToWorktreeGroup);
-    const { username, group } = flags;
-    try {
-      execSync(UnixGroupCommands.isUserInGroup(username, group), { stdio: "ignore" });
+    const { username, group, verbose } = flags;
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    const isInGroup = await executor.check(UnixGroupCommands.isUserInGroup(username, group));
+    if (isInGroup) {
       this.log(`\u2705 User ${username} is already in group ${group}`);
       return;
-    } catch {
     }
     try {
-      execSync(UnixGroupCommands.addUserToGroup(username, group), { stdio: "inherit" });
+      await executor.exec(UnixGroupCommands.addUserToGroup(username, group));
       this.log(`\u2705 Added user ${username} to group ${group}`);
     } catch (error) {
       this.error(`Failed to add user ${username} to group ${group}: ${error}`);

package/dist/cli/commands/admin/create-symlink.d.ts

@@ -9,6 +9,8 @@ declare class CreateSymlink extends Command {
         'worktree-name': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         'worktree-path': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         'home-base': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/create-symlink.js

@@ -1,7 +1,7 @@
 // src/commands/admin/create-symlink.ts
-import { execSync } from "child_process";
 import {
   AGOR_HOME_BASE,
+  createAdminExecutor,
   getWorktreeSymlinkPath,
   isValidUnixUsername,
   SymlinkCommands
@@ -10,7 +10,8 @@ import { Command, Flags } from "@oclif/core";
 var CreateSymlink = class _CreateSymlink extends Command {
   static description = "Create a worktree symlink in user home directory (admin only)";
   static examples = [
-    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature --worktree-path /var/agor/worktrees/abc123"
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature --worktree-path /var/agor/worktrees/abc123",
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature --worktree-path /var/agor/worktrees/abc123 --dry-run"
   ];
   static flags = {
     username: Flags.string({
@@ -19,7 +20,7 @@ var CreateSymlink = class _CreateSymlink extends Command {
       required: true
     }),
     "worktree-name": Flags.string({
-      char: "n",
+      char: "w",
       description: "Worktree name/slug (symlink name)",
       required: true
     }),
@@ -31,14 +32,29 @@ var CreateSymlink = class _CreateSymlink extends Command {
     "home-base": Flags.string({
       description: "Base directory for home directories",
       default: AGOR_HOME_BASE
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_CreateSymlink);
-    const { username } = flags;
+    const { username, verbose } = flags;
     const worktreeName = flags["worktree-name"];
     const worktreePath = flags["worktree-path"];
     const homeBase = flags["home-base"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
     if (!isValidUnixUsername(username)) {
       this.error(`Invalid Unix username format: ${username}`);
     }
@@ -47,9 +63,8 @@ var CreateSymlink = class _CreateSymlink extends Command {
     }
     const linkPath = getWorktreeSymlinkPath(username, worktreeName, homeBase);
     try {
-      const existingTarget = execSync(SymlinkCommands.readSymlink(linkPath), {
-        encoding: "utf-8"
-      }).trim();
+      const result = await executor.exec(SymlinkCommands.readSymlink(linkPath));
+      const existingTarget = result.stdout.trim();
       if (existingTarget === worktreePath) {
         this.log(`\u2705 Symlink already exists: ${linkPath} -> ${worktreePath}`);
         return;
@@ -58,9 +73,9 @@ var CreateSymlink = class _CreateSymlink extends Command {
     } catch {
     }
     try {
-      execSync(SymlinkCommands.createSymlinkWithOwnership(worktreePath, linkPath, username), {
-        stdio: "inherit"
-      });
+      await executor.execAll(
+        SymlinkCommands.createSymlinkWithOwnership(worktreePath, linkPath, username)
+      );
       this.log(`\u2705 Created symlink: ${linkPath} -> ${worktreePath}`);
     } catch (error) {
       this.error(`Failed to create symlink: ${error}`);

package/dist/cli/commands/admin/create-worktree-group.d.ts

@@ -6,6 +6,8 @@ declare class CreateWorktreeGroup extends Command {
     static examples: string[];
     static flags: {
         'worktree-id': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/create-worktree-group.js

@@ -1,6 +1,6 @@
 // src/commands/admin/create-worktree-group.ts
-import { execSync } from "child_process";
 import {
+  createAdminExecutor,
   generateWorktreeGroupName,
   isValidWorktreeGroupName,
   UnixGroupCommands
@@ -9,30 +9,46 @@ import { Command, Flags } from "@oclif/core";
 var CreateWorktreeGroup = class _CreateWorktreeGroup extends Command {
   static description = "Create a Unix group for a worktree (admin only)";
   static examples = [
-    "<%= config.bin %> <%= command.id %> --worktree-id 03b62447-f2c6-4259-997b-d38ed1ddafed"
+    "<%= config.bin %> <%= command.id %> --worktree-id 03b62447-f2c6-4259-997b-d38ed1ddafed",
+    "<%= config.bin %> <%= command.id %> --worktree-id 03b62447-f2c6-4259-997b-d38ed1ddafed --dry-run"
   ];
   static flags = {
     "worktree-id": Flags.string({
       char: "w",
       description: "Worktree ID (full UUID)",
       required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_CreateWorktreeGroup);
     const worktreeId = flags["worktree-id"];
+    const dryRun = flags["dry-run"];
+    const verbose = flags.verbose;
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
     const groupName = generateWorktreeGroupName(worktreeId);
     if (!isValidWorktreeGroupName(groupName)) {
       this.error(`Invalid group name format: ${groupName}`);
     }
-    try {
-      execSync(UnixGroupCommands.groupExists(groupName), { stdio: "ignore" });
+    const groupExists = await executor.check(UnixGroupCommands.groupExists(groupName));
+    if (groupExists) {
       this.log(`\u2705 Group ${groupName} already exists`);
       return;
-    } catch {
     }
     try {
-      execSync(UnixGroupCommands.createGroup(groupName), { stdio: "inherit" });
+      await executor.exec(UnixGroupCommands.createGroup(groupName));
       this.log(`\u2705 Created Unix group: ${groupName}`);
     } catch (error) {
       this.error(`Failed to create group ${groupName}: ${error}`);

package/dist/cli/commands/admin/delete-user.d.ts

@@ -7,6 +7,8 @@ declare class DeleteUser extends Command {
     static flags: {
         username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         'delete-home': _oclif_core_interfaces.BooleanFlag<boolean>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/delete-user.js

@@ -1,12 +1,12 @@
 // src/commands/admin/delete-user.ts
-import { execSync } from "child_process";
-import { isValidUnixUsername, UnixUserCommands } from "@agor/core/unix";
+import { createAdminExecutor, isValidUnixUsername, UnixUserCommands } from "@agor/core/unix";
 import { Command, Flags } from "@oclif/core";
 var DeleteUser = class _DeleteUser extends Command {
   static description = "Delete a Unix user (admin only)";
   static examples = [
     "<%= config.bin %> <%= command.id %> --username agor_03b62447",
-    "<%= config.bin %> <%= command.id %> --username agor_03b62447 --delete-home"
+    "<%= config.bin %> <%= command.id %> --username agor_03b62447 --delete-home",
+    "<%= config.bin %> <%= command.id %> --username agor_03b62447 --dry-run"
   ];
   static flags = {
     username: Flags.string({
@@ -17,27 +17,41 @@ var DeleteUser = class _DeleteUser extends Command {
     "delete-home": Flags.boolean({
       description: "Also delete the user home directory",
       default: false
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_DeleteUser);
-    const { username } = flags;
+    const { username, verbose } = flags;
     const deleteHome = flags["delete-home"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
     if (!isValidUnixUsername(username)) {
       this.error(`Invalid Unix username format: ${username}`);
     }
-    try {
-      execSync(UnixUserCommands.userExists(username), { stdio: "ignore" });
-    } catch {
+    const userExists = await executor.check(UnixUserCommands.userExists(username));
+    if (!userExists) {
       this.log(`\u2705 Unix user ${username} does not exist (nothing to do)`);
       return;
     }
     try {
       if (deleteHome) {
-        execSync(UnixUserCommands.deleteUserWithHome(username), { stdio: "inherit" });
+        await executor.exec(UnixUserCommands.deleteUserWithHome(username));
         this.log(`\u2705 Deleted Unix user ${username} and home directory`);
       } else {
-        execSync(UnixUserCommands.deleteUser(username), { stdio: "inherit" });
+        await executor.exec(UnixUserCommands.deleteUser(username));
         this.log(`\u2705 Deleted Unix user ${username} (home directory preserved)`);
       }
     } catch (error) {

package/dist/cli/commands/admin/delete-worktree-group.d.ts

@@ -6,6 +6,8 @@ declare class DeleteWorktreeGroup extends Command {
     static examples: string[];
     static flags: {
         group: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/delete-worktree-group.js

@@ -1,28 +1,44 @@
 // src/commands/admin/delete-worktree-group.ts
-import { execSync } from "child_process";
-import { UnixGroupCommands } from "@agor/core/unix";
+import { createAdminExecutor, UnixGroupCommands } from "@agor/core/unix";
 import { Command, Flags } from "@oclif/core";
 var DeleteWorktreeGroup = class _DeleteWorktreeGroup extends Command {
   static description = "Delete a worktree Unix group (admin only)";
-  static examples = ["<%= config.bin %> <%= command.id %> --group agor_wt_03b62447"];
+  static examples = [
+    "<%= config.bin %> <%= command.id %> --group agor_wt_03b62447",
+    "<%= config.bin %> <%= command.id %> --group agor_wt_03b62447 --dry-run"
+  ];
   static flags = {
     group: Flags.string({
       char: "g",
       description: "Unix group name to delete (e.g., agor_wt_03b62447)",
       required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_DeleteWorktreeGroup);
-    const { group } = flags;
-    try {
-      execSync(UnixGroupCommands.groupExists(group), { stdio: "ignore" });
-    } catch {
-      this.log(`\u2705 Group ${group} doesn't exist`);
+    const { group, verbose } = flags;
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    const groupExists = await executor.check(UnixGroupCommands.groupExists(group));
+    if (!groupExists) {
+      this.log(`\u2705 Group ${group} doesn't exist (nothing to do)`);
       return;
     }
     try {
-      execSync(UnixGroupCommands.deleteGroup(group), { stdio: "inherit" });
+      await executor.exec(UnixGroupCommands.deleteGroup(group));
       this.log(`\u2705 Deleted Unix group: ${group}`);
     } catch (error) {
       this.error(`Failed to delete group ${group}: ${error}`);

package/dist/cli/commands/admin/ensure-user.d.ts

@@ -7,6 +7,8 @@ declare class EnsureUser extends Command {
     static flags: {
         username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         'home-base': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/ensure-user.js

@@ -1,12 +1,17 @@
 // src/commands/admin/ensure-user.ts
-import { execSync } from "child_process";
-import { AGOR_HOME_BASE, isValidUnixUsername, UnixUserCommands } from "@agor/core/unix";
+import {
+  AGOR_HOME_BASE,
+  createAdminExecutor,
+  isValidUnixUsername,
+  UnixUserCommands
+} from "@agor/core/unix";
 import { Command, Flags } from "@oclif/core";
 var EnsureUser = class _EnsureUser extends Command {
   static description = "Ensure a Unix user exists with proper Agor setup (admin only)";
   static examples = [
     "<%= config.bin %> <%= command.id %> --username agor_03b62447",
-    "<%= config.bin %> <%= command.id %> --username alice --home-base /home"
+    "<%= config.bin %> <%= command.id %> --username alice --home-base /home",
+    "<%= config.bin %> <%= command.id %> --username alice --dry-run"
   ];
   static flags = {
     username: Flags.string({
@@ -17,31 +22,46 @@ var EnsureUser = class _EnsureUser extends Command {
     "home-base": Flags.string({
       description: "Base directory for home directories",
       default: AGOR_HOME_BASE
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_EnsureUser);
-    const { username } = flags;
+    const { username, verbose } = flags;
     const homeBase = flags["home-base"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
     if (!isValidUnixUsername(username)) {
       this.error(`Invalid Unix username format: ${username}`);
     }
-    try {
-      execSync(UnixUserCommands.userExists(username), { stdio: "ignore" });
+    const userExists = await executor.check(UnixUserCommands.userExists(username));
+    if (userExists) {
       this.log(`\u2705 Unix user ${username} already exists`);
       try {
-        execSync(UnixUserCommands.setupWorktreesDir(username, homeBase), { stdio: "inherit" });
+        await executor.execAll(UnixUserCommands.setupWorktreesDir(username, homeBase));
         this.log(`\u2705 Ensured ~/agor/worktrees directory for ${username}`);
       } catch (error) {
         this.warn(`Failed to setup worktrees directory: ${error}`);
       }
       return;
-    } catch {
     }
     try {
-      execSync(UnixUserCommands.createUser(username, "/bin/bash", homeBase), { stdio: "inherit" });
+      this.log(`Creating Unix user: ${username}`);
+      await executor.exec(UnixUserCommands.createUser(username, "/bin/bash", homeBase));
       this.log(`\u2705 Created Unix user: ${username}`);
-      execSync(UnixUserCommands.setupWorktreesDir(username, homeBase), { stdio: "inherit" });
+      await executor.execAll(UnixUserCommands.setupWorktreesDir(username, homeBase));
       this.log(`\u2705 Created ~/agor/worktrees directory for ${username}`);
     } catch (error) {
       this.error(`Failed to create user ${username}: ${error}`);

package/dist/cli/commands/admin/remove-from-worktree-group.d.ts

@@ -7,6 +7,8 @@ declare class RemoveFromWorktreeGroup extends Command {
     static flags: {
         username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         group: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/remove-from-worktree-group.js

@@ -1,11 +1,11 @@
 // src/commands/admin/remove-from-worktree-group.ts
-import { execSync } from "child_process";
-import { UnixGroupCommands } from "@agor/core/unix";
+import { createAdminExecutor, UnixGroupCommands } from "@agor/core/unix";
 import { Command, Flags } from "@oclif/core";
 var RemoveFromWorktreeGroup = class _RemoveFromWorktreeGroup extends Command {
   static description = "Remove a user from a worktree Unix group (admin only)";
   static examples = [
-    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447"
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447",
+    "<%= config.bin %> <%= command.id %> --username alice --group agor_wt_03b62447 --dry-run"
   ];
   static flags = {
     username: Flags.string({
@@ -17,19 +17,33 @@ var RemoveFromWorktreeGroup = class _RemoveFromWorktreeGroup extends Command {
       char: "g",
       description: "Unix group name (e.g., agor_wt_03b62447)",
       required: true
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_RemoveFromWorktreeGroup);
-    const { username, group } = flags;
-    try {
-      execSync(UnixGroupCommands.isUserInGroup(username, group), { stdio: "ignore" });
-    } catch {
-      this.log(`\u2705 User ${username} is not in group ${group}`);
+    const { username, group, verbose } = flags;
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
+    const isInGroup = await executor.check(UnixGroupCommands.isUserInGroup(username, group));
+    if (!isInGroup) {
+      this.log(`\u2705 User ${username} is not in group ${group} (nothing to do)`);
       return;
     }
     try {
-      execSync(UnixGroupCommands.removeUserFromGroup(username, group), { stdio: "inherit" });
+      await executor.exec(UnixGroupCommands.removeUserFromGroup(username, group));
       this.log(`\u2705 Removed user ${username} from group ${group}`);
     } catch (error) {
       this.error(`Failed to remove user ${username} from group ${group}: ${error}`);

package/dist/cli/commands/admin/remove-symlink.d.ts

@@ -8,6 +8,8 @@ declare class RemoveSymlink extends Command {
         username: _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         'worktree-name': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
         'home-base': _oclif_core_interfaces.OptionFlag<string, _oclif_core_interfaces.CustomOptions>;
+        'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
+        verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/cli/commands/admin/remove-symlink.js

@@ -1,7 +1,7 @@
 // src/commands/admin/remove-symlink.ts
-import { execSync } from "child_process";
 import {
   AGOR_HOME_BASE,
+  createAdminExecutor,
   getWorktreeSymlinkPath,
   isValidUnixUsername,
   SymlinkCommands
@@ -10,7 +10,8 @@ import { Command, Flags } from "@oclif/core";
 var RemoveSymlink = class _RemoveSymlink extends Command {
   static description = "Remove a worktree symlink from user home directory (admin only)";
   static examples = [
-    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature"
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature",
+    "<%= config.bin %> <%= command.id %> --username alice --worktree-name my-feature --dry-run"
   ];
   static flags = {
     username: Flags.string({
@@ -19,32 +20,46 @@ var RemoveSymlink = class _RemoveSymlink extends Command {
       required: true
     }),
     "worktree-name": Flags.string({
-      char: "n",
+      char: "w",
       description: "Worktree name/slug (symlink name)",
       required: true
     }),
     "home-base": Flags.string({
       description: "Base directory for home directories",
       default: AGOR_HOME_BASE
+    }),
+    "dry-run": Flags.boolean({
+      char: "n",
+      description: "Show what would be done without making changes",
+      default: false
+    }),
+    verbose: Flags.boolean({
+      char: "v",
+      description: "Show detailed output including command stdout/stderr",
+      default: false
     })
   };
   async run() {
     const { flags } = await this.parse(_RemoveSymlink);
-    const { username } = flags;
+    const { username, verbose } = flags;
     const worktreeName = flags["worktree-name"];
     const homeBase = flags["home-base"];
+    const dryRun = flags["dry-run"];
+    const executor = createAdminExecutor({ "dry-run": dryRun, verbose });
+    if (dryRun) {
+      this.log("\u{1F50D} Dry run mode - no changes will be made\n");
+    }
     if (!isValidUnixUsername(username)) {
       this.error(`Invalid Unix username format: ${username}`);
     }
     const linkPath = getWorktreeSymlinkPath(username, worktreeName, homeBase);
-    try {
-      execSync(SymlinkCommands.symlinkExists(linkPath), { stdio: "ignore" });
-    } catch {
+    const symlinkExists = await executor.check(SymlinkCommands.symlinkExists(linkPath));
+    if (!symlinkExists) {
       this.log(`\u2705 Symlink does not exist: ${linkPath} (nothing to do)`);
       return;
     }
     try {
-      execSync(SymlinkCommands.removeSymlink(linkPath), { stdio: "inherit" });
+      await executor.exec(SymlinkCommands.removeSymlink(linkPath));
       this.log(`\u2705 Removed symlink: ${linkPath}`);
     } catch (error) {
       this.error(`Failed to remove symlink: ${error}`);

package/dist/cli/commands/admin/sync-unix.d.ts

@@ -7,13 +7,9 @@ declare class SyncUnix extends Command {
     static flags: {
         'dry-run': _oclif_core_interfaces.BooleanFlag<boolean>;
         verbose: _oclif_core_interfaces.BooleanFlag<boolean>;
-        'create-users': _oclif_core_interfaces.BooleanFlag<boolean>;
-        'sync-groups': _oclif_core_interfaces.BooleanFlag<boolean>;
-        'create-groups': _oclif_core_interfaces.BooleanFlag<boolean>;
         cleanup: _oclif_core_interfaces.BooleanFlag<boolean>;
         'cleanup-groups': _oclif_core_interfaces.BooleanFlag<boolean>;
         'cleanup-users': _oclif_core_interfaces.BooleanFlag<boolean>;
-        'repair-worktree-perms': _oclif_core_interfaces.BooleanFlag<boolean>;
     };
     /**
      * Check if a Unix user exists on the system
@@ -27,6 +23,10 @@ declare class SyncUnix extends Command {
      * Check if a Unix group exists
      */
     private groupExists;
+    /**
+     * Check if a Unix user is in a group
+     */
+    private isUserInGroup;
     /**
      * Create a Unix user (assumes running as root via sudo)
      */
@@ -55,6 +55,10 @@ declare class SyncUnix extends Command {
      * List all agor_wt_* groups on the system
      */
     private listWorktreeGroups;
+    /**
+     * List all agor_rp_* (repo) groups on the system
+     */
+    private listRepoGroups;
     run(): Promise<void>;
 }