git-worktree-organize 1.0.13 → 1.1.1

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { resolve as resolve3, join as join3, dirname as dirname2, basename as basename2 } from "node:path";
-import { existsSync as existsSync3 } from "node:fs";
+import { resolve as resolve3, join as join5, dirname as dirname3, basename as basename3 } from "node:path";
+import { existsSync as existsSync5, statSync as statSync5, readFileSync as readFileSync5, readdirSync as readdirSync3 } from "node:fs";
 
 // src/run.ts
 import { spawnSync } from "node:child_process";
@@ -46,8 +46,7 @@ async function detect(repoPath) {
       }
     } else if (stat.isFile()) {
       const contents = readFileSync(gitEntryPath, "utf8");
-      const firstLine = contents.split(`
-`)[0].trim();
+      const firstLine = contents.split("\n")[0].trim();
       const match = firstLine.match(/^gitdir:\s*(.+)$/);
       if (!match) {
         throw new Error(`not a git repository: ${repoPath}`);
@@ -80,10 +79,8 @@ function parsePorcelain(output) {
   const worktrees = [];
   const blocks = output.trim().split(/\n\n+/);
   for (const block of blocks) {
-    if (!block.trim())
-      continue;
-    const lines = block.trim().split(`
-`);
+    if (!block.trim()) continue;
+    const lines = block.trim().split("\n");
     let path = "";
     let head = "";
     let branch = null;
@@ -113,131 +110,296 @@ async function listWorktrees(repoPath) {
 }
 
 // src/migrate.ts
-import { mkdirSync, writeFileSync, readFileSync as readFileSync2, existsSync as existsSync2, renameSync, statSync as statSync2, readdirSync } from "node:fs";
-import { join as join2, dirname, basename, resolve as resolve2 } from "node:path";
+import { mkdirSync, writeFileSync, readFileSync as readFileSync2, existsSync as existsSync3, statSync as statSync3, readdirSync, renameSync as renameSync2 } from "node:fs";
+import { join as join2, dirname as dirname2, basename, resolve as resolve2 } from "node:path";
 
 // src/git.ts
 async function git(args, options) {
   const result = run("git", args, {
     cwd: options?.cwd,
-    env: options?.env ? { ...process.env, ...options.env } : undefined
+    env: options?.env ? { ...process.env, ...options.env } : void 0
   });
   return result.stdout;
 }
 async function setGitConfig(key, value, options) {
   const env = {};
-  if (options?.gitdir)
-    env["GIT_DIR"] = options.gitdir;
+  if (options?.gitdir) env["GIT_DIR"] = options.gitdir;
   await git(["config", key, value], { cwd: options?.cwd, env });
 }
 
-// src/migrate.ts
-async function moveDir(src, dest) {
+// src/fs.ts
+import { statSync as statSync2, renameSync, existsSync as existsSync2 } from "node:fs";
+import { dirname } from "node:path";
+async function move(src, dest) {
   const destForStat = existsSync2(dest) ? dest : dirname(dest);
-  if (statSync2(src).dev === statSync2(destForStat).dev) {
+  if (samefs(src, destForStat)) {
     renameSync(src, dest);
   } else {
     run("cp", ["-a", src, dest]);
     run("rm", ["-rf", src]);
   }
 }
+function samefs(a, b) {
+  return statSync2(a).dev === statSync2(b).dev;
+}
+
+// src/migrate.ts
+var AGENTS_MD_TEMPLATE = `# Git Worktree Layout
+
+This repository uses **git worktrees** with a bare repository pattern for parallel development across multiple branches.
+
+## Directory Structure
+
+\`\`\`
+<project>/                        # Root project directory
+\u251C\u2500\u2500 .bare/                        # Bare git repository (shared git data)
+\u2502   \u251C\u2500\u2500 worktrees/               # Worktree metadata
+\u2502   \u2502   \u251C\u2500\u2500 main/                # Main branch metadata
+\u2502   \u2502   \u2514\u2500\u2500 <branch-name>/       # Per-branch worktree metadata
+\u2502   \u251C\u2500\u2500 objects/                 # Git objects (shared)
+\u2502   \u251C\u2500\u2500 refs/                    # Git refs (shared)
+\u2502   \u2514\u2500\u2500 config                   # Repository config
+\u251C\u2500\u2500 .git                         # Points to .bare (gitdir: ./.bare)
+\u251C\u2500\u2500 main/                        # Main branch worktree (primary)
+\u251C\u2500\u2500 <branch-name>/               # Feature/fix branch worktrees
+\u2514\u2500\u2500 *.code-workspace             # VS Code multi-root workspace
+\`\`\`
+
+## How It Works
+
+- **Bare Repository**: \`.bare/\` contains all git data (objects, refs, config)
+- **Worktrees**: Each branch checkout is a separate directory at the root level
+- **Shared History**: All worktrees share the same git history from \`.bare/\`
+
+## Working with Worktrees
+
+### Create a new worktree
+
+\`\`\`bash
+# From any worktree or the root
+git worktree add <branch-name>
+
+# Create new branch and worktree
+git worktree add -b <new-branch> <directory-name>
+\`\`\`
+
+### List worktrees
+
+\`\`\`bash
+git worktree list
+\`\`\`
+
+### Remove a worktree
+
+\`\`\`bash
+# After merging/deleting the branch
+git worktree remove <branch-name>
+
+# Force removal (if untracked files exist)
+git worktree remove --force <branch-name>
+\`\`\`
+
+### Prune stale worktree references
+
+\`\`\`bash
+git worktree prune
+\`\`\`
+
+## Conventions
+
+1. **Naming**: Worktree directories match the branch name (e.g., \`feature-auth\`, \`fix-login-bug\`)
+2. **Main worktree**: \`main/\` is the primary worktree for the main branch
+3. **Workspace file**: Open \`*.code-workspace\` in VS Code to work with multiple worktrees
+
+## Tips
+
+- Each worktree has its own \`.git\` file pointing back to \`.bare/\`
+- You can run different branches simultaneously without stashing
+- IDEs can open multiple worktrees as separate folders in one workspace
+- Run \`git worktree prune\` periodically to clean up deleted worktree references
+`;
+function writeAgentsMd(dest) {
+  const agentsPath = join2(dest, "AGENTS.md");
+  if (!existsSync3(agentsPath)) {
+    writeFileSync(agentsPath, AGENTS_MD_TEMPLATE);
+  }
+}
+function worktreeConfigEnabled(bareDir) {
+  const configFile = join2(bareDir, "config");
+  if (!existsSync3(configFile)) return false;
+  const content = readFileSync2(configFile, "utf8");
+  const extensionsMatch = content.match(/\[extensions\]([\s\S]*?)(?=\[|$)/i);
+  if (!extensionsMatch) return false;
+  return /worktreeconfig\s*=\s*true/i.test(extensionsMatch[1]);
+}
+var WORKTREE_CONFIG_CONTENT = "[core]\n	bare = false\n";
+function ensureWorktreeConfig(adminDir, bareDir, log) {
+  if (!worktreeConfigEnabled(bareDir)) return;
+  const configWtFile = join2(adminDir, "config.worktree");
+  if (!existsSync3(configWtFile) || readFileSync2(configWtFile, "utf8") !== WORKTREE_CONFIG_CONTENT) {
+    log?.(`Writing config.worktree for [${basename(adminDir)}]`);
+    writeFileSync(configWtFile, WORKTREE_CONFIG_CONTENT);
+  }
+}
 function sanitizeBranch(branch) {
   return branch.replace(/\//g, "-");
 }
 function resolveWorktreePath(worktreePath, dest, sourceParent) {
-  if (existsSync2(worktreePath))
-    return worktreePath;
+  if (existsSync3(worktreePath)) return worktreePath;
   if (worktreePath.startsWith(dest + "/")) {
     const remapped = sourceParent + worktreePath.slice(dest.length);
-    if (existsSync2(remapped))
-      return remapped;
+    if (existsSync3(remapped)) return remapped;
   }
   return worktreePath;
 }
 function isPartialMigration(dest) {
   const gitFile = join2(dest, ".git");
-  return existsSync2(join2(dest, ".bare")) && existsSync2(gitFile) && statSync2(gitFile).isFile();
+  return existsSync3(join2(dest, ".bare")) && existsSync3(gitFile) && statSync3(gitFile).isFile();
 }
 function findHub(startPath) {
   let current = resolve2(startPath);
   while (true) {
-    if (isPartialMigration(current))
-      return current;
-    const parent = dirname(current);
-    if (parent === current)
-      return null;
+    if (isPartialMigration(current)) return current;
+    const parent = dirname2(current);
+    if (parent === current) return null;
     current = parent;
   }
 }
 async function repairHub(dest, log = console.log) {
   const adminBase = join2(dest, ".bare", "worktrees");
-  if (!existsSync2(adminBase))
-    return;
+  if (!existsSync3(adminBase)) return;
   for (const adminName of readdirSync(adminBase)) {
     const adminDir = join2(adminBase, adminName);
-    if (!statSync2(adminDir).isDirectory())
-      continue;
+    if (!statSync3(adminDir).isDirectory()) continue;
     const gitdirFile = join2(adminDir, "gitdir");
-    if (!existsSync2(gitdirFile))
-      continue;
+    if (!existsSync3(gitdirFile)) continue;
     const registeredGitFile = readFileSync2(gitdirFile, "utf8").trim();
-    const worktreePath = dirname(registeredGitFile);
-    if (!worktreePath.startsWith(dest + "/"))
-      continue;
-    if (!existsSync2(registeredGitFile) || !statSync2(registeredGitFile).isFile())
-      continue;
+    const worktreePath = dirname2(registeredGitFile);
+    if (!worktreePath.startsWith(dest + "/")) continue;
+    if (!existsSync3(registeredGitFile) || !statSync3(registeredGitFile).isFile()) continue;
+    const commondirFile = join2(adminDir, "commondir");
+    const expectedCommondir = "../../\n";
+    if (!existsSync3(commondirFile) || readFileSync2(commondirFile, "utf8") !== expectedCommondir) {
+      log(`Repairing commondir for [${basename(worktreePath)}]`);
+      writeFileSync(commondirFile, expectedCommondir);
+    }
+    ensureWorktreeConfig(adminDir, join2(dest, ".bare"), log);
     const content = readFileSync2(registeredGitFile, "utf8");
     const match = content.match(/^gitdir:\s*(.+)/m);
-    if (!match)
-      continue;
-    if (match[1].trim() === adminDir)
-      continue;
+    if (!match) continue;
+    if (match[1].trim() === adminDir) continue;
     log(`Repairing .git for [${basename(worktreePath)}]`);
     writeFileSync(registeredGitFile, `gitdir: ${adminDir}
 `);
   }
 }
-async function resumeMigrate(dest, log = console.log) {
+async function resumeMigrate(dest, log = console.log, warn) {
   const destBare = join2(dest, ".bare");
   const hubWorktrees = await listWorktrees(dest);
   const pending = hubWorktrees.filter((wt) => {
-    if (wt.isBare)
-      return false;
+    if (wt.isBare) return false;
     const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
     return wt.path !== join2(dest, sanitizeBranch(branch));
   });
   if (pending.length === 0) {
-    log("Nothing to resume — all worktrees are already in place.");
+    log("Nothing to resume \u2014 all worktrees are already in place.");
   } else {
     for (const wt of pending) {
       const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
       const expectedPath = join2(dest, sanitizeBranch(branch));
       let wtPath = wt.path;
-      if (!existsSync2(wtPath)) {
-        if (existsSync2(expectedPath)) {
+      if (!existsSync3(wtPath)) {
+        if (existsSync3(expectedPath)) {
           wtPath = expectedPath;
         } else {
-          log(`warn: Skipping [${branch}] — path no longer exists: ${wt.path}`);
+          log(`warn: Skipping [${branch}] \u2014 path no longer exists: ${wt.path}`);
           continue;
         }
       }
-      log(`Moving [${branch}] → ${expectedPath}`);
-      await processLinkedWorktree({ ...wt, path: wtPath }, dest, destBare);
+      log(`Moving [${branch}] \u2192 ${expectedPath}`);
+      await processLinkedWorktree({ ...wt, path: wtPath }, dest, destBare, log, warn);
     }
   }
   await repairHub(dest, log);
   return dest;
 }
-async function migrate(config, options) {
+async function migrateInPlace(source, log = console.log, warn) {
+  const resolvedSource = resolve2(source);
+  const oldPath = resolvedSource + ".old";
+  if (existsSync3(oldPath)) {
+    throw new Error(`'${oldPath}' already exists. Remove it and try again.`);
+  }
+  log(`Renaming ${bold(resolvedSource)} to ${bold(oldPath)}`);
+  await move(resolvedSource, oldPath);
+  const allWorktrees = await listWorktrees(oldPath);
+  const worktrees = allWorktrees.filter((wt) => !wt.isBare);
+  if (worktrees.length === 0) {
+    throw new Error("No worktrees found in source repository");
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const wt of worktrees) {
+    const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+    const safe = sanitizeBranch(branch);
+    if (seen.has(safe)) {
+      throw new Error(`branch name collision: '${seen.get(safe)}' and '${branch}' both map to '${safe}'`);
+    }
+    seen.set(safe, branch);
+  }
+  const mainBranch = worktrees[0].branch;
+  const mainSafe = sanitizeBranch(mainBranch);
+  const destBare = join2(resolvedSource, ".bare");
+  const mainDest = join2(resolvedSource, mainSafe);
+  mkdirSync(destBare, { recursive: true });
+  const gitDir = join2(oldPath, ".git");
+  for (const entry of readdirSync(gitDir)) {
+    const srcPath = join2(gitDir, entry);
+    const destPath = join2(destBare, entry);
+    if (statSync3(srcPath).isDirectory()) {
+      run("cp", ["-a", srcPath + "/.", destPath + "/"]);
+    } else {
+      run("cp", ["-a", srcPath, destPath]);
+    }
+  }
+  await setGitConfig("core.bare", "true", { gitdir: destBare });
+  await setGitConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*", { gitdir: destBare });
+  writeFileSync(join2(resolvedSource, ".git"), "gitdir: ./.bare\n");
+  const mainHeadContent = readFileSync2(join2(destBare, "HEAD"), "utf8");
+  log(`Creating main worktree at ${bold(mainDest)}`);
+  run("cp", ["-a", oldPath + "/.", mainDest + "/"]);
+  const mainAdminDir = join2(destBare, "worktrees", mainSafe);
+  mkdirSync(mainAdminDir, { recursive: true });
+  writeFileSync(join2(mainAdminDir, "gitdir"), mainDest + "/.git\n");
+  writeFileSync(join2(mainAdminDir, "commondir"), "../../\n");
+  ensureWorktreeConfig(mainAdminDir, destBare);
+  const headToWrite = mainHeadContent.endsWith("\n") ? mainHeadContent : mainHeadContent + "\n";
+  writeFileSync(join2(mainAdminDir, "HEAD"), headToWrite);
+  const bareIndex = join2(destBare, "index");
+  if (existsSync3(bareIndex)) {
+    renameSync2(bareIndex, join2(mainAdminDir, "index"));
+  }
+  run("rm", ["-rf", join2(mainDest, ".git")]);
+  writeFileSync(join2(mainDest, ".git"), `gitdir: ${mainAdminDir}
+`);
+  for (let i = 1; i < worktrees.length; i++) {
+    await processLinkedWorktree(worktrees[i], resolvedSource, destBare, log, warn);
+  }
+  log(`Original repo backed up at: ${oldPath}`);
+  writeAgentsMd(resolvedSource);
+  return resolvedSource;
+}
+function bold(s) {
+  return `\x1B[1m${s}\x1B[0m`;
+}
+async function migrate(config, options, log, warn) {
   const source = resolve2(options.source);
-  const dest = options.dest ? resolve2(options.dest) : join2(dirname(source), basename(source) + "-bare");
+  const dest = options.dest ? resolve2(options.dest) : join2(dirname2(source), basename(source) + "-bare");
   const destBare = join2(dest, ".bare");
-  if (existsSync2(destBare)) {
+  if (existsSync3(destBare)) {
     throw new Error(`'${destBare}' already exists`);
   }
   const allWorktrees = await listWorktrees(source);
   const worktrees = allWorktrees.filter((wt) => !wt.isBare);
-  const seen = new Map;
+  const seen = /* @__PURE__ */ new Map();
   for (const wt of worktrees) {
     const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
     const safe = sanitizeBranch(branch);
@@ -250,53 +412,52 @@ async function migrate(config, options) {
   run("cp", ["-a", config.gitdir + "/.", destBare + "/"]);
   await setGitConfig("core.bare", "true", { gitdir: destBare });
   await setGitConfig("remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*", { gitdir: destBare });
-  writeFileSync(join2(dest, ".git"), `gitdir: ./.bare
-`);
-  const sourceParent = dirname(source);
-  const worktreesResolved = worktrees.map((wt, i) => i === 0 && config.type === "standard" ? wt : { ...wt, path: resolveWorktreePath(wt.path, dest, sourceParent) });
+  writeFileSync(join2(dest, ".git"), "gitdir: ./.bare\n");
+  const sourceParent = dirname2(source);
+  const worktreesResolved = worktrees.map(
+    (wt, i) => i === 0 && config.type === "standard" ? wt : { ...wt, path: resolveWorktreePath(wt.path, dest, sourceParent) }
+  );
   if (config.type === "standard") {
     const mainBranch = worktrees[0].branch;
     const mainSafe = sanitizeBranch(mainBranch);
     const mainDest = join2(dest, mainSafe);
     const mainHeadContent = readFileSync2(join2(destBare, "HEAD"), "utf8");
     run("rm", ["-rf", join2(source, ".git")]);
-    await moveDir(source, mainDest);
+    await move(source, mainDest);
     const mainAdminDir = join2(destBare, "worktrees", mainSafe);
     mkdirSync(mainAdminDir, { recursive: true });
-    writeFileSync(join2(mainAdminDir, "gitdir"), mainDest + `/.git
-`);
-    writeFileSync(join2(mainAdminDir, "commondir"), `../../
-`);
-    const headToWrite = mainHeadContent.endsWith(`
-`) ? mainHeadContent : mainHeadContent + `
-`;
+    writeFileSync(join2(mainAdminDir, "gitdir"), mainDest + "/.git\n");
+    writeFileSync(join2(mainAdminDir, "commondir"), "../../\n");
+    ensureWorktreeConfig(mainAdminDir, destBare);
+    const headToWrite = mainHeadContent.endsWith("\n") ? mainHeadContent : mainHeadContent + "\n";
     writeFileSync(join2(mainAdminDir, "HEAD"), headToWrite);
     const bareIndex = join2(destBare, "index");
-    if (existsSync2(bareIndex)) {
-      renameSync(bareIndex, join2(mainAdminDir, "index"));
+    if (existsSync3(bareIndex)) {
+      renameSync2(bareIndex, join2(mainAdminDir, "index"));
     }
     writeFileSync(join2(mainDest, ".git"), `gitdir: ${mainAdminDir}
 `);
-    for (let i = 1;i < worktreesResolved.length; i++) {
-      await processLinkedWorktree(worktreesResolved[i], dest, destBare);
+    for (let i = 1; i < worktreesResolved.length; i++) {
+      await processLinkedWorktree(worktreesResolved[i], dest, destBare, log, warn);
     }
   } else {
     for (const wt of worktreesResolved) {
-      await processLinkedWorktree(wt, dest, destBare);
+      await processLinkedWorktree(wt, dest, destBare, log, warn);
     }
   }
+  writeAgentsMd(dest);
   return dest;
 }
-async function processLinkedWorktree(wt, dest, destBare) {
+async function processLinkedWorktree(wt, dest, destBare, log, warn) {
   const wtSrc = wt.path;
   const wtBranch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
   const wtSafe = sanitizeBranch(wtBranch);
   const wtDest = join2(dest, wtSafe);
-  await moveDir(wtSrc, wtDest);
+  await move(wtSrc, wtDest);
   const gitFileContent = readFileSync2(join2(wtDest, ".git"), "utf8");
   const match = gitFileContent.match(/^gitdir:\s*(.+)/m);
   if (!match) {
-    console.warn(`Could not parse .git file in ${wtDest}`);
+    warn?.(`Could not parse .git file in ${wtDest}`);
     return;
   }
   const oldPath = match[1].trim();
@@ -304,17 +465,102 @@ async function processLinkedWorktree(wt, dest, destBare) {
   const newAdmin = join2(destBare, "worktrees", adminName);
   writeFileSync(join2(wtDest, ".git"), `gitdir: ${newAdmin}
 `);
-  if (existsSync2(newAdmin)) {
-    writeFileSync(join2(newAdmin, "gitdir"), wtDest + `/.git
-`);
+  if (existsSync3(newAdmin)) {
+    writeFileSync(join2(newAdmin, "gitdir"), wtDest + "/.git\n");
+    writeFileSync(join2(newAdmin, "commondir"), "../../\n");
+    ensureWorktreeConfig(newAdmin, destBare);
   } else {
-    console.warn(`Admin dir ${newAdmin} does not exist for worktree ${wtDest}`);
+    warn?.(`Admin dir ${newAdmin} does not exist for worktree ${wtDest}`);
   }
 }
 
+// src/recover.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3, basename as basename2 } from "node:path";
+async function searchForWorktree(branch, options, log) {
+  const sanitizedBranch = sanitizeBranch(branch);
+  const candidates = [];
+  for (const searchDir of options.searchDirs) {
+    searchAtDepth(searchDir, sanitizedBranch, 0, options.maxDepth, candidates, log);
+  }
+  const validCandidates = candidates.filter((c) => {
+    const gitPath = join3(c, ".git");
+    return existsSync4(gitPath) && statSync4(gitPath).isFile();
+  });
+  return {
+    branch,
+    sanitizedBranch,
+    foundPath: validCandidates.length === 1 ? validCandidates[0] : null,
+    candidates: validCandidates
+  };
+}
+function searchAtDepth(dir, targetName, currentDepth, maxDepth, candidates, log) {
+  if (currentDepth > maxDepth) return;
+  if (!existsSync4(dir)) return;
+  const entries = readdirSync2(dir);
+  for (const entry of entries) {
+    if (entry.startsWith(".") || entry === "node_modules") continue;
+    const fullPath = join3(dir, entry);
+    if (!statSync4(fullPath).isDirectory()) continue;
+    if (entry === targetName) {
+      log?.(`Found candidate: ${fullPath}`);
+      candidates.push(fullPath);
+    }
+    searchAtDepth(fullPath, targetName, currentDepth + 1, maxDepth, candidates, log);
+  }
+}
+async function findMissingWorktrees(hubPath, searchDirs, log) {
+  const worktrees = await listWorktrees(hubPath);
+  const results = [];
+  for (const wt of worktrees) {
+    if (wt.isBare) continue;
+    if (existsSync4(wt.path)) continue;
+    const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+    log?.(`Searching for missing worktree [${branch}]...`);
+    const result = await searchForWorktree(branch, { searchDirs, maxDepth: 3 }, log);
+    results.push(result);
+  }
+  return results;
+}
+async function repairWorktree(worktreePath, hubPath, log) {
+  const bareDir = join3(hubPath, ".bare");
+  const adminBase = join3(bareDir, "worktrees");
+  const gitFile = join3(worktreePath, ".git");
+  const content = readFileSync3(gitFile, "utf8");
+  const match = content.match(/^gitdir:\s*(.+)/m);
+  if (!match) {
+    throw new Error(`Cannot parse .git file in ${worktreePath}`);
+  }
+  const oldAdminPath = match[1].trim();
+  const adminName = basename2(oldAdminPath);
+  const newAdminPath = join3(adminBase, adminName);
+  log?.(`Repairing ${worktreePath} -> ${newAdminPath}`);
+  writeFileSync2(gitFile, `gitdir: ${newAdminPath}
+`);
+  const gitdirFile = join3(newAdminPath, "gitdir");
+  if (existsSync4(gitdirFile)) {
+    writeFileSync2(gitdirFile, `${worktreePath}/.git
+`);
+  }
+}
+
+// src/version.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+function readVersion() {
+  const pkgPath = join4(import.meta.dirname, "..", "package.json");
+  const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+  return pkg.version;
+}
+var VERSION = readVersion();
+function getVersion(withPrefix = false) {
+  return withPrefix ? `v${VERSION}` : VERSION;
+}
+
 // src/cli.ts
 var GREEN = "\x1B[32m";
 var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
 var BOLD = "\x1B[1m";
 var RESET = "\x1B[0m";
 function green(s) {
@@ -323,7 +569,10 @@ function green(s) {
 function yellow(s) {
   return `${YELLOW}${s}${RESET}`;
 }
-function bold(s) {
+function red(s) {
+  return `${RED}${s}${RESET}`;
+}
+function bold2(s) {
   return `${BOLD}${s}${RESET}`;
 }
 function prompt() {
@@ -332,37 +581,254 @@ function prompt() {
     process.stdin.once("data", (chunk) => res(chunk.toString().trim()));
   });
 }
+function isGitPointerValid(worktreePath, hubPath) {
+  const gitFile = join5(worktreePath, ".git");
+  if (!existsSync5(gitFile) || !statSync5(gitFile).isFile()) {
+    return false;
+  }
+  const content = readFileSync5(gitFile, "utf8");
+  const match = content.match(/^gitdir:\s*(.+)$/m);
+  if (!match) {
+    return false;
+  }
+  const adminDir = match[1].trim();
+  const bareDir = join5(hubPath, ".bare");
+  if (!adminDir.includes(bareDir) || !adminDir.includes("/worktrees/")) {
+    return false;
+  }
+  if (!existsSync5(adminDir)) {
+    return false;
+  }
+  const adminGitdirFile = join5(adminDir, "gitdir");
+  if (!existsSync5(adminGitdirFile)) {
+    return false;
+  }
+  const adminGitdir = readFileSync5(adminGitdirFile, "utf8").trim();
+  if (adminGitdir !== gitFile) {
+    return false;
+  }
+  const commondirFile = join5(adminDir, "commondir");
+  if (!existsSync5(commondirFile) || readFileSync5(commondirFile, "utf8").trim() !== "../..") {
+    return false;
+  }
+  const sharedConfig = join5(hubPath, ".bare", "config");
+  if (existsSync5(sharedConfig)) {
+    const cfg = readFileSync5(sharedConfig, "utf8");
+    const extMatch = cfg.match(/\[extensions\]([\s\S]*?)(?=\[|$)/i);
+    if (extMatch && /worktreeconfig\s*=\s*true/i.test(extMatch[1])) {
+      const configWt = join5(adminDir, "config.worktree");
+      if (!existsSync5(configWt) || !readFileSync5(configWt, "utf8").includes("bare = false")) {
+        return false;
+      }
+    }
+  }
+  try {
+    run("git", ["-C", worktreePath, "rev-parse", "HEAD"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listWorktreesFromAdminDirs(hubPath) {
+  const adminBase = join5(hubPath, ".bare", "worktrees");
+  if (!existsSync5(adminBase)) return [];
+  const worktrees = [];
+  for (const adminName of readdirSync3(adminBase)) {
+    const adminDir = join5(adminBase, adminName);
+    if (!statSync5(adminDir).isDirectory()) continue;
+    const gitdirFile = join5(adminDir, "gitdir");
+    if (!existsSync5(gitdirFile)) continue;
+    const wtGitFile = readFileSync5(gitdirFile, "utf8").trim();
+    const wtPath = dirname3(wtGitFile);
+    const headFile = join5(adminDir, "HEAD");
+    let branch = null;
+    let head = "";
+    if (existsSync5(headFile)) {
+      const headContent = readFileSync5(headFile, "utf8").trim();
+      if (headContent.startsWith("ref: refs/heads/")) {
+        branch = headContent.slice("ref: refs/heads/".length);
+      } else {
+        head = headContent;
+      }
+    }
+    worktrees.push({ path: wtPath, head, branch, isBare: false });
+  }
+  return worktrees;
+}
+async function runValidationMode(hubPath) {
+  let worktrees;
+  try {
+    worktrees = await listWorktrees(hubPath);
+  } catch {
+    console.log(`${yellow("warn:")} git worktree list failed; scanning admin dirs to enumerate worktrees`);
+    worktrees = listWorktreesFromAdminDirs(hubPath);
+  }
+  const validated = [];
+  for (const wt of worktrees) {
+    if (wt.isBare) continue;
+    let status;
+    if (!existsSync5(wt.path)) {
+      status = "missing";
+    } else if (!isGitPointerValid(wt.path, hubPath)) {
+      status = "stale";
+    } else {
+      status = "healthy";
+    }
+    validated.push({ worktree: wt, status });
+  }
+  console.log();
+  console.log(bold2("Validation Report"));
+  console.log(`Hub: ${hubPath}`);
+  console.log();
+  if (validated.length === 0) {
+    console.log("No worktrees found.");
+    return;
+  }
+  const maxBranchLen = validated.reduce((m, v) => {
+    const branch = v.worktree.branch ?? `detached-${v.worktree.head.slice(0, 8)}`;
+    return Math.max(m, branch.length);
+  }, 0);
+  const headerBranch = "Branch".padEnd(maxBranchLen);
+  const headerStatus = "Status";
+  const headerPath = "Path";
+  console.log(`  ${bold2(headerBranch)}  ${bold2(headerStatus.padEnd(7))}  ${bold2(headerPath)}`);
+  const counts = { healthy: 0, missing: 0, stale: 0 };
+  for (const v of validated) {
+    const branch = v.worktree.branch ?? `detached-${v.worktree.head.slice(0, 8)}`;
+    const branchCol = branch.padEnd(maxBranchLen);
+    let statusCol;
+    if (v.status === "healthy") {
+      statusCol = green("healthy");
+      counts.healthy++;
+    } else if (v.status === "missing") {
+      statusCol = red("missing");
+      counts.missing++;
+    } else {
+      statusCol = yellow("stale");
+      counts.stale++;
+    }
+    console.log(`  ${branchCol}  ${statusCol.padEnd(7 + (statusCol.length - v.status.length))}  ${v.worktree.path}`);
+  }
+  console.log();
+  const summaryParts = [];
+  if (counts.healthy > 0) summaryParts.push(`${counts.healthy} healthy`);
+  if (counts.missing > 0) summaryParts.push(`${counts.missing} missing`);
+  if (counts.stale > 0) summaryParts.push(`${counts.stale} stale`);
+  console.log(`Summary: ${summaryParts.join(", ")}`);
+  const staleWorktrees = validated.filter((v) => v.status === "stale");
+  if (staleWorktrees.length > 0) {
+    console.log();
+    console.log(`${green("==>")} Auto-repairing ${staleWorktrees.length} stale worktree(s)...`);
+    await repairHub(hubPath, (msg) => console.log(`  ${msg}`));
+  }
+  const needsRepair = validated.filter((v) => v.status === "missing");
+  if (needsRepair.length === 0) {
+    return;
+  }
+  console.log();
+  console.log(`${yellow("warn:")} ${needsRepair.length} missing worktree(s) need repair.`);
+  const searchDirs = [dirname3(hubPath)];
+  console.log(`${green("==>")} Searching for missing worktrees...`);
+  const results = await findMissingWorktrees(
+    hubPath,
+    searchDirs,
+    (msg) => console.log(`    ${msg}`)
+  );
+  const found = results.filter((r) => r.candidates.length > 0);
+  const notFound = results.filter((r) => r.candidates.length === 0);
+  const multiple = results.filter((r) => r.candidates.length > 1);
+  if (notFound.length > 0) {
+    console.log(`
+${yellow("Not found:")}`);
+    for (const r of notFound) {
+      console.log(`  [${r.branch}]`);
+    }
+  }
+  if (found.length === 0) {
+    console.log(`
+No worktrees could be located. Consider pruning them with 'git worktree prune'.`);
+    return;
+  }
+  const selections = /* @__PURE__ */ new Map();
+  for (const r of multiple) {
+    console.log(`
+${bold2(`[${r.branch}]`)} has multiple candidates:`);
+    for (let i = 0; i < r.candidates.length; i++) {
+      console.log(`  ${i + 1}) ${r.candidates[i]}`);
+    }
+    process.stdout.write(`Select which to use (1-${r.candidates.length}) [skip]: `);
+    const sel = await prompt();
+    const idx = parseInt(sel) - 1;
+    if (idx >= 0 && idx < r.candidates.length) {
+      selections.set(r.branch, r.candidates[idx]);
+    }
+  }
+  console.log(`
+${green("Found:")}`);
+  const maxFoundBranchLen = found.reduce((m, r) => Math.max(m, r.branch.length), 0);
+  for (const r of found) {
+    const path = selections.get(r.branch) ?? r.candidates[0];
+    const branchCol = bold2(`[${r.branch}]`).padEnd(maxFoundBranchLen + 2 + BOLD.length + RESET.length);
+    console.log(`  ${branchCol}  ${path}`);
+  }
+  console.log();
+  process.stdout.write("Repair these worktrees? [y/N] ");
+  const repairAns = await prompt();
+  process.stdin.destroy();
+  if (!/^[Yy]$/.test(repairAns)) {
+    console.log("Aborted.");
+    return;
+  }
+  console.log();
+  for (const r of found) {
+    const path = selections.get(r.branch) ?? r.candidates[0];
+    await repairWorktree(path, hubPath, (msg) => console.log(`${green("==>")} ${msg}`));
+  }
+  console.log(`${green("==>")} Repaired ${found.length} worktree(s).`);
+}
 function usage() {
   console.log(`Usage: git-worktree-organize <source> [destination]
 
 Convert a git repository into the canonical bare-hub worktree layout:
 
-  <dest>/.bare/    ← bare git repo
-  <dest>/.git      ← plain file: "gitdir: ./.bare"
-  <dest>/<branch>/ ← one directory per worktree
+  <dest>/.bare/    \u2190 bare git repo
+  <dest>/.git      \u2190 plain file: "gitdir: ./.bare"
+  <dest>/<branch>/ \u2190 one directory per worktree
 
 Arguments:
   source       Path to existing git repository
   destination  Target hub directory (default: <parent>/<name>-bare)
 
 Options:
-  -h, --help   Show help`);
+  -h, --help      Show help
+  -v, --version   Show version`);
 }
 async function main() {
   const args = process.argv.slice(2);
+  if (args[0] === "-v" || args[0] === "--version") {
+    console.log(`git-worktree-organize ${getVersion(true)}`);
+    process.exit(0);
+  }
   if (args.length === 0 || args[0] === "-h" || args[0] === "--help") {
     usage();
     process.exit(0);
   }
+  console.log(`${bold2("git-worktree-organize")} ${getVersion(true)}
+`);
   const sourcePath = args[0];
   const destArg = args[1];
   const source = resolve3(sourcePath);
-  const dest = isPartialMigration(source) ? source : destArg ? resolve3(destArg) : join3(dirname2(source), basename2(source) + "-bare");
+  const dest = isPartialMigration(source) ? source : destArg ? resolve3(destArg) : join5(dirname3(source), basename3(source) + "-bare");
+  const config = await detect(source);
+  if (config.type === "bare-hub") {
+    await runValidationMode(source);
+    process.exit(0);
+  }
   if (!isPartialMigration(source) && !destArg) {
-    const ancestorHub = findHub(dirname2(source));
+    const ancestorHub = findHub(dirname3(source));
     if (ancestorHub) {
       console.log(`
-${yellow("warn:")} ${bold(source)} is inside an existing hub at ${bold(ancestorHub)}`);
+${yellow("warn:")} ${bold2(source)} is inside an existing hub at ${bold2(ancestorHub)}`);
       console.log(`
 This looks like manually-placed worktrees with stale .git files.`);
       console.log(`Running repair will fix all worktree .git connections in the hub.
@@ -386,24 +852,104 @@ This looks like manually-placed worktrees with stale .git files.`);
   if (isPartialMigration(dest)) {
     const hubWorktrees = await listWorktrees(dest);
     const pending = hubWorktrees.filter((wt) => {
-      if (wt.isBare)
-        return false;
+      if (wt.isBare) return false;
       const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
-      return wt.path !== join3(dest, sanitizeBranch(branch));
+      return wt.path !== join5(dest, sanitizeBranch(branch));
+    });
+    const missing2 = hubWorktrees.filter((wt) => {
+      if (wt.isBare) return false;
+      return !existsSync5(wt.path);
     });
     console.log(`
-${yellow("warn:")} Partial migration detected at ${bold(dest)}`);
+${yellow("warn:")} Partial migration detected at ${bold2(dest)}`);
+    if (missing2.length > 0) {
+      console.log(`
+The following worktree paths no longer exist:`);
+      for (const wt of missing2) {
+        const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+        console.log(`  [${branch}]  ${wt.path}`);
+      }
+      console.log();
+      const searchDirs = [dirname3(dest)];
+      console.log(`${green("==>")} Searching for missing worktrees...`);
+      const results = await findMissingWorktrees(
+        dest,
+        searchDirs,
+        (msg) => console.log(`    ${msg}`)
+      );
+      const found = results.filter((r) => r.candidates.length > 0);
+      const notFound = results.filter((r) => r.candidates.length === 0);
+      const multiple = results.filter((r) => r.candidates.length > 1);
+      if (notFound.length > 0) {
+        console.log(`
+${yellow("Not found:")}`);
+        for (const r of notFound) {
+          console.log(`  [${r.branch}]`);
+        }
+      }
+      if (found.length === 0) {
+        console.log(`
+No worktrees could be located. Consider pruning them with 'git worktree prune'.`);
+        process.exit(0);
+      }
+      const selections = /* @__PURE__ */ new Map();
+      for (const r of multiple) {
+        console.log(`
+${bold2(`[${r.branch}]`)} has multiple candidates:`);
+        for (let i = 0; i < r.candidates.length; i++) {
+          console.log(`  ${i + 1}) ${r.candidates[i]}`);
+        }
+        process.stdout.write(`Select which to use (1-${r.candidates.length}) [skip]: `);
+        const sel = await prompt();
+        const idx = parseInt(sel) - 1;
+        if (idx >= 0 && idx < r.candidates.length) {
+          selections.set(r.branch, r.candidates[idx]);
+        }
+      }
+      console.log(`
+${green("Found:")}`);
+      const maxBranchLen = found.reduce((m, r) => Math.max(m, r.branch.length), 0);
+      for (const r of found) {
+        const path = selections.get(r.branch) ?? r.candidates[0];
+        const branchCol = bold2(`[${r.branch}]`).padEnd(maxBranchLen + 2 + BOLD.length + RESET.length);
+        console.log(`  ${branchCol}  ${path}`);
+      }
+      console.log();
+      process.stdout.write("Repair these worktrees? [y/N] ");
+      const repairAns = await prompt();
+      if (!/^[Yy]$/.test(repairAns)) {
+        console.log("Aborted.");
+        process.stdin.destroy();
+        process.exit(0);
+      }
+      console.log();
+      for (const r of found) {
+        const path = selections.get(r.branch) ?? r.candidates[0];
+        await repairWorktree(path, dest, (msg) => console.log(`${green("==>")} ${msg}`));
+      }
+      console.log(`${green("==>")} Repaired ${found.length} worktree(s).
+`);
+      const refreshed = await listWorktrees(dest);
+      hubWorktrees.length = 0;
+      hubWorktrees.push(...refreshed);
+      pending.length = 0;
+      pending.push(...hubWorktrees.filter((wt) => {
+        if (wt.isBare) return false;
+        const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+        return wt.path !== join5(dest, sanitizeBranch(branch));
+      }));
+    }
     if (pending.length === 0) {
-      console.log("All worktrees are already in place — nothing to resume.");
+      await runValidationMode(dest);
       process.exit(0);
     }
     console.log(`
 Worktrees still to move:`);
     for (const wt of pending) {
       const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
-      const exists = existsSync3(wt.path);
+      const exists = existsSync5(wt.path);
       const status = exists ? "" : `  ${yellow("(path missing)")}`;
-      console.log(`  [${bold(branch)}]  ${wt.path}  →  ${join3(dest, sanitizeBranch(branch))}${status}`);
+      console.log(`  [${bold2(branch)}]  ${wt.path}  \u2192  ${join5(dest, sanitizeBranch(branch))}${status}`);
     }
     console.log();
     process.stdout.write("Resume migration? [y/N] ");
@@ -413,7 +959,11 @@ Worktrees still to move:`);
       process.exit(0);
     }
     console.log();
-    const hubPath2 = await resumeMigrate(dest, (msg) => console.log(`${green("==>")} ${msg}`));
+    const hubPath2 = await resumeMigrate(
+      dest,
+      (msg) => console.log(`${green("==>")} ${msg}`),
+      (msg) => console.log(`${yellow("warn:")} ${msg}`)
+    );
     console.log();
     console.log(`${green("==>")} Verifying with git worktree list...`);
     console.log(run("git", ["-C", hubPath2, "worktree", "list"]).stdout);
@@ -423,30 +973,132 @@ Worktrees still to move:`);
   console.log(`
 ${green("==>")} Reading worktrees from ${source}
 `);
-  const config = await detect(source);
   const allWorktrees = await listWorktrees(source);
+  if (config.type === "standard" && !destArg) {
+    const repoName = basename3(source);
+    let mainBranch2 = "main";
+    if (allWorktrees.length > 0) {
+      mainBranch2 = allWorktrees[0].branch ?? "main";
+    }
+    console.log("Worktrees to migrate:");
+    const maxNameLen2 = allWorktrees.reduce((m, wt) => {
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      return Math.max(m, branch.length);
+    }, 0);
+    for (const wt of allWorktrees) {
+      const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
+      const safe = sanitizeBranch(branch);
+      const isMain = branch === mainBranch2;
+      const destDir = join5(source, safe);
+      const nameCol = bold2(`[${branch}]`).padEnd(maxNameLen2 + 2 + BOLD.length + RESET.length);
+      const annotation = isMain ? `  (labeled ${yellow("[main]")})`.padEnd(18 + YELLOW.length + RESET.length) : "".padEnd(18);
+      console.log(`  ${nameCol}${annotation}  \u2192  ${destDir}`);
+    }
+    console.log();
+    console.log(`Hub destination: ${bold2(source)}  (bare repo at ${source}/.bare)`);
+    console.log();
+    console.log(`No destination specified. Migrate in-place?`);
+    console.log(`This will rename '${bold2(repoName)}' to '${bold2(repoName + ".old")}' and create the hub here.`);
+    console.log();
+    process.stdout.write("Proceed with in-place migration? [y/N] ");
+    const inPlaceAns = await prompt();
+    process.stdin.destroy();
+    if (!/^[Yy]$/.test(inPlaceAns)) {
+      console.log("Aborted.");
+      console.log("Tip: Specify a destination directory to migrate to a new location.");
+      process.exit(0);
+    }
+    console.log();
+    const hubPath2 = await migrateInPlace(
+      source,
+      (msg) => console.log(`${green("==>")} ${msg}`),
+      (msg) => console.log(`${yellow("warn:")} ${msg}`)
+    );
+    console.log(`${green("==>")} Verifying with git worktree list...`);
+    const verifyOutput2 = run("git", ["-C", hubPath2, "worktree", "list"]).stdout;
+    console.log(verifyOutput2);
+    console.log(`Done! Hub: ${hubPath2}`);
+    console.log(`Backup: ${source}.old`);
+    console.log();
+    console.log("Useful commands:");
+    console.log(`  git -C ${hubPath2} worktree list`);
+    console.log(`  git -C ${hubPath2}/main log --oneline -5`);
+    process.exit(0);
+  }
   const missing = allWorktrees.filter((wt) => {
-    if (wt.isBare)
-      return false;
-    const actual = resolveWorktreePath(wt.path, dest, dirname2(source));
-    return !existsSync3(actual);
+    if (wt.isBare) return false;
+    const actual = resolveWorktreePath(wt.path, dest, dirname3(source));
+    return !existsSync5(actual);
   });
   if (missing.length > 0) {
-    console.log(`${yellow("warn:")} The following worktree paths no longer exist:`);
+    console.log(`
+${yellow("warn:")} The following worktree paths no longer exist:`);
     for (const wt of missing) {
       const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
       console.log(`  [${branch}]  ${wt.path}`);
     }
     console.log();
-    process.stdout.write("Remove them with `git worktree prune` and continue? [y/N] ");
-    const pruneAns = await prompt();
-    if (!/^[Yy]$/.test(pruneAns)) {
+    const searchDirs = [dirname3(source)];
+    if (dest !== source) {
+      searchDirs.push(dest);
+    }
+    console.log(`${green("==>")} Searching for missing worktrees...`);
+    const results = await findMissingWorktrees(
+      source,
+      searchDirs,
+      (msg) => console.log(`    ${msg}`)
+    );
+    const found = results.filter((r) => r.candidates.length > 0);
+    const notFound = results.filter((r) => r.candidates.length === 0);
+    const multiple = results.filter((r) => r.candidates.length > 1);
+    if (notFound.length > 0) {
+      console.log(`
+${yellow("Not found:")}`);
+      for (const r of notFound) {
+        console.log(`  [${r.branch}]`);
+      }
+    }
+    if (found.length === 0) {
+      console.log(`
+No worktrees could be located. Consider pruning them with 'git worktree prune'.`);
+      process.exit(0);
+    }
+    const selections = /* @__PURE__ */ new Map();
+    for (const r of multiple) {
+      console.log(`
+${bold2(`[${r.branch}]`)} has multiple candidates:`);
+      for (let i = 0; i < r.candidates.length; i++) {
+        console.log(`  ${i + 1}) ${r.candidates[i]}`);
+      }
+      process.stdout.write(`Select which to use (1-${r.candidates.length}) [skip]: `);
+      const sel = await prompt();
+      const idx = parseInt(sel) - 1;
+      if (idx >= 0 && idx < r.candidates.length) {
+        selections.set(r.branch, r.candidates[idx]);
+      }
+    }
+    console.log(`
+${green("Found:")}`);
+    const maxBranchLen = found.reduce((m, r) => Math.max(m, r.branch.length), 0);
+    for (const r of found) {
+      const path = selections.get(r.branch) ?? r.candidates[0];
+      const branchCol = bold2(`[${r.branch}]`).padEnd(maxBranchLen + 2 + BOLD.length + RESET.length);
+      console.log(`  ${branchCol}  ${path}`);
+    }
+    console.log();
+    process.stdout.write("Repair these worktrees? [y/N] ");
+    const repairAns = await prompt();
+    if (!/^[Yy]$/.test(repairAns)) {
       console.log("Aborted.");
       process.stdin.destroy();
       process.exit(0);
     }
-    run("git", ["-C", source, "worktree", "prune"]);
-    console.log(`${green("==>")} Pruned stale worktrees.
+    console.log();
+    for (const r of found) {
+      const path = selections.get(r.branch) ?? r.candidates[0];
+      await repairWorktree(path, source, (msg) => console.log(`${green("==>")} ${msg}`));
+    }
+    console.log(`${green("==>")} Repaired ${found.length} worktree(s).
 `);
     const refreshed = await listWorktrees(source);
     allWorktrees.length = 0;
@@ -462,19 +1114,19 @@ ${green("==>")} Reading worktrees from ${source}
     const branch = wt.branch ?? `detached-${wt.head.slice(0, 8)}`;
     const safe = sanitizeBranch(branch);
     const isMain = branch === mainBranch;
-    const destDir = join3(dest, safe);
+    const destDir = join5(dest, safe);
     return { branch, isMain, destDir };
   });
   const maxNameLen = entries.reduce((m, e) => Math.max(m, e.branch.length), 0);
   for (const { branch, isMain, destDir } of entries) {
     const tag = isMain ? yellow("[main]") : "";
     const tagPad = isMain ? `  (labeled ${yellow("[main]")})` : "";
-    const nameCol = bold(`[${branch}]`).padEnd(maxNameLen + 2 + BOLD.length + RESET.length);
+    const nameCol = bold2(`[${branch}]`).padEnd(maxNameLen + 2 + BOLD.length + RESET.length);
     const annotation = isMain ? `  (labeled ${yellow("[main]")})`.padEnd(18 + YELLOW.length + RESET.length) : "".padEnd(18);
-    console.log(`  ${nameCol}${annotation}  →  ${destDir}`);
+    console.log(`  ${nameCol}${annotation}  \u2192  ${destDir}`);
   }
   console.log();
-  console.log(`Hub destination: ${bold(dest)}  (bare repo at ${dest}/.bare)`);
+  console.log(`Hub destination: ${bold2(dest)}  (bare repo at ${dest}/.bare)`);
   console.log();
   process.stdout.write("Proceed? [y/N] ");
   const ans = await prompt();
@@ -484,7 +1136,12 @@ ${green("==>")} Reading worktrees from ${source}
     process.exit(0);
   }
   console.log();
-  const hubPath = await migrate(config, { source: sourcePath, dest: destArg ?? "" });
+  const hubPath = await migrate(
+    config,
+    { source: sourcePath, dest: destArg ?? "" },
+    (msg) => console.log(`${green("==>")} ${msg}`),
+    (msg) => console.log(`${yellow("warn:")} ${msg}`)
+  );
   console.log(`${green("==>")} Verifying with git worktree list...`);
   const verifyOutput = run("git", ["-C", hubPath, "worktree", "list"]).stdout;
   console.log(verifyOutput);