@shivanshshrivas/gwit 0.1.2 → 0.2.0

package/README.md

@@ -26,9 +26,16 @@ gwit -b fix/login-page        # create a new branch from HEAD
 
 # Day-to-day
 gwit list                     # show all active worktrees
+gwit status                   # see ahead/behind, dirty state, PR info
 gwit sync feature/auth        # re-copy files after .env changes
+gwit sync --back feature/auth # three-way merge .gwitinclude files back to main
 gwit open feature/auth        # re-open editor for an existing worktree
+
+# Merge and clean up
+gwit merge feature/auth       # merge branch back into main
 gwit remove feature/auth      # run cleanup hooks and remove worktree
+gwit sweep                    # bulk-remove all merged worktrees
+gwit rename old/name new/name # rename a worktree branch
 ```
 
 ## How it works
@@ -102,13 +109,26 @@ gwit remove feature/auth --force   # skip uncommitted-changes check
 
 ### `gwit sync [branch]`
 
-Re-copy `.gwitinclude` files into an existing worktree. Use this when your `.env` gains a new key, certs rotate, or `node_modules` is updated.
+By default, re-copy `.gwitinclude` files from main into an existing worktree.  
+With `--back`, sync in the reverse direction using snapshot-aware three-way merge.
 
 ```sh
 gwit sync feature/auth   # sync a specific branch
 gwit sync                # auto-detect from current directory (when inside a worktree)
+gwit sync --back feature/auth  # three-way merge worktree -> main
+gwit sync --back               # auto-detect branch, then merge back
 ```
 
+`--back` compares three versions of each snapshot-tracked file:
+
+1. **base** - file content captured when the worktree was created
+2. **main** - current file in the main worktree
+3. **worktree** - current file in the linked worktree
+
+If both sides changed different text regions, gwit applies a clean merge.  
+If both sides changed the same region, gwit writes git-style conflict markers  
+(`<<<<<<<`, `=======`, `>>>>>>>`). Binary conflicts are skipped with a warning.
+
 ### `gwit open <branch>`
 
 Re-open the editor for an existing worktree. Useful when the editor window was closed.
@@ -118,6 +138,62 @@ gwit open feature/auth
 gwit open feature/auth --editor cursor
 ```
 
+### `gwit merge <branch>`
+
+Merge a worktree branch back into the target branch. Combines git-tracked changes (via real git merge) with gitignored files (via reverse `.gwitinclude` sync) in a single command.
+
+```sh
+gwit merge feature/auth               # standard merge into default branch
+gwit merge feature/auth --into dev    # merge into a specific branch
+gwit merge feature/auth --squash      # squash all commits into one
+gwit merge feature/auth --rebase      # rebase onto target, then fast-forward
+gwit merge feature/auth --no-ff       # force a merge commit
+gwit merge feature/auth --cleanup     # remove worktree after successful merge
+gwit merge feature/auth --no-sync-back  # skip reverse .gwitinclude copy
+```
+
+What it does, in order:
+
+1. Validates the worktree exists in the registry
+2. Resolves the target branch (default: repo's default branch)
+3. Three-way syncs `.gwitinclude` files back to main (falls back to direct copy if no snapshot; unless `--no-sync-back`)
+4. Checks out the target branch in the main worktree
+5. Merges the feature branch using the chosen strategy
+6. Optionally removes the worktree (`--cleanup`)
+
+If the merge fails with conflicts, gwit exits with a helpful message so you can resolve manually.
+
+### `gwit status`
+
+Show detailed status of all active gwit worktrees.
+
+```sh
+gwit status          # rich table output
+gwit status --json   # machine-readable JSON
+```
+
+Displays per-worktree: branch, path, port, ahead/behind counts, dirty-file count, and PR info (if [`gh` CLI](https://cli.github.com) is installed).
+
+### `gwit sweep`
+
+Bulk-remove worktrees whose branches are fully merged into the default branch or whose GitHub PRs are merged/closed.
+
+```sh
+gwit sweep             # interactive confirmation
+gwit sweep --dry-run   # show what would be removed
+gwit sweep --force     # skip confirmation
+```
+
+Runs cleanup hooks for each removed worktree, just like `gwit remove`.
+
+### `gwit rename <old-branch> <new-branch>`
+
+Rename a worktree's git branch, move the directory (if the slug changes), and update the registry atomically.
+
+```sh
+gwit rename feature/auth feature/authentication
+```
+
 ### `gwit config`
 
 Show or update global configuration stored in `~/.gwitrc`.
@@ -145,15 +221,19 @@ gwit config set basePort 4000      # starting port for auto-assignment
 
 ### `.gwitinclude`
 
-List of gitignored files and directories to copy into every new worktree. One entry per line, comments with `#` ignored.
+List of gitignored files and directories to copy into every new worktree. One entry per line, comments with `#` ignored. Supports glob patterns via [minimatch](https://github.com/isaacs/minimatch).
 
 ```
 # .gwitinclude - files to copy into each new worktree
 .env
 .env.local
 certs/
+*.pem
+secrets/**
 ```
 
+Glob patterns (`*`, `?`, `[...]`, `**`) are expanded against the set of gitignored files in the repo. Literal entries are copied directly.
+
 Only gitignored files are eligible to copy. Tracked files are silently skipped - gwit is an allowlist for files that must be present but cannot be committed.
 
 ### `.gwitcommand`

package/dist/index.cjs

@@ -24,8 +24,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var fs8 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
 var import_commander = require("commander");
 
 // src/types.ts
@@ -54,21 +54,21 @@ function colorize(text, code) {
   return `${code}${text}${ANSI.reset}`;
 }
 var ui = {
-  /** Prints a green success line prefixed with ✓. */
+  // Prints a green success line prefixed with ✓.
   success: (msg) => console.log(colorize(`\u2713 ${msg}`, ANSI.green)),
-  /** Prints a red error line to stderr prefixed with ✗. */
+  // Prints a red error line to stderr prefixed with ✗.
   error: (msg) => console.error(colorize(`\u2717 ${msg}`, ANSI.red)),
-  /** Prints a yellow warning line to stderr prefixed with ⚠. */
+  // Prints a yellow warning line to stderr prefixed with ⚠.
   warn: (msg) => console.warn(colorize(`\u26A0 ${msg}`, ANSI.yellow)),
-  /** Prints a cyan informational line. */
+  // Prints a cyan informational line.
   info: (msg) => console.log(colorize(`  ${msg}`, ANSI.cyan)),
-  /** Prints a cyan step line prefixed with →. */
+  // Prints a cyan step line prefixed with →.
   step: (msg) => console.log(colorize(`\u2192 ${msg}`, ANSI.cyan)),
-  /** Prints a dimmed line (secondary information). */
+  // Prints a dimmed line (secondary information).
   dim: (msg) => console.log(colorize(msg, ANSI.dim)),
-  /** Returns bold-wrapped text (for embedding in other strings). */
+  // Returns bold-wrapped text (for embedding in other strings).
   bold: (text) => colorize(text, ANSI.bold),
-  /** Returns gray-wrapped text (for embedding in other strings). */
+  // Returns gray-wrapped text (for embedding in other strings).
   gray: (text) => colorize(text, ANSI.gray)
 };
 function formatError(err) {
@@ -108,6 +108,12 @@ function getGwitDir() {
 function getRegistryPath() {
   return path.join(getGwitDir(), "worktrees.json");
 }
+function getSnapshotsDir() {
+  return path.join(getGwitDir(), "snapshots");
+}
+function getSnapshotDir(slug) {
+  return path.join(getSnapshotsDir(), slug);
+}
 function getConfigPath() {
   return path.join(os.homedir(), ".gwitrc");
 }
@@ -154,6 +160,18 @@ function runArgsSafe(cmd, args, options) {
   const stdout = (result.stdout ?? "").trim();
   return { stdout, success: result.status === 0 };
 }
+function runArgsWithExitCode(cmd, args, options) {
+  const result = (0, import_child_process.spawnSync)(cmd, args, {
+    encoding: "utf-8",
+    cwd: options?.cwd,
+    env: options?.env ? { ...process.env, ...options.env } : process.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return {
+    stdout: (result.stdout ?? "").trim(),
+    exitCode: result.status ?? 1
+  };
+}
 function runSafe(command, options) {
   try {
     const stdout = (0, import_child_process.execSync)(command, {
@@ -173,11 +191,11 @@ function _parseWorktreePorcelain(output) {
   const blocks = output.trim().split(/\n\n+/);
   return blocks.filter(Boolean).map((block) => {
     const lines = block.split("\n");
-    const path7 = lines.find((l) => l.startsWith("worktree "))?.slice(9) ?? "";
+    const path9 = lines.find((l) => l.startsWith("worktree "))?.slice(9) ?? "";
     const head = lines.find((l) => l.startsWith("HEAD "))?.slice(5) ?? "";
     const branchLine = lines.find((l) => l.startsWith("branch "));
     const branch = branchLine ? branchLine.slice(7).replace("refs/heads/", "") : null;
-    return { path: path7, head, branch };
+    return { path: path9, head, branch };
   }).filter((w) => w.path.length > 0);
 }
 function isGitRepo() {
@@ -210,6 +228,9 @@ function branchExistsRemote(branch) {
   const result = runArgsSafe("git", ["ls-remote", "--heads", "origin", branch]);
   return result.success && result.stdout.length > 0;
 }
+function fetchOrigin() {
+  runArgsInherited("git", ["fetch", "origin"]);
+}
 function addWorktree(worktreePath, branch, isNew) {
   const args = isNew ? ["worktree", "add", "-b", branch, worktreePath] : ["worktree", "add", worktreePath, branch];
   runArgsInherited("git", args);
@@ -223,6 +244,56 @@ function hasUncommittedChanges(worktreePath) {
   const result = runArgsSafe("git", ["-C", worktreePath, "status", "--porcelain"]);
   return result.success && result.stdout.length > 0;
 }
+function isBranchMerged(branch, into) {
+  const result = runArgsSafe("git", ["branch", "--merged", into]);
+  if (!result.success) return false;
+  return result.stdout.split("\n").some((line) => line.trim().replace(/^\*\s*/, "") === branch);
+}
+function getDefaultBranch() {
+  const symref = runArgsSafe("git", ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+  if (symref.success && symref.stdout.length > 0) {
+    return symref.stdout.replace("refs/remotes/origin/", "");
+  }
+  if (branchExistsLocal("main")) return "main";
+  if (branchExistsLocal("master")) return "master";
+  throw new GwitError(
+    "Could not determine the default branch.",
+    "Specify the target explicitly: gwit merge <branch> --into main"
+  );
+}
+function getAheadBehind(branch, base, cwd) {
+  const args = cwd ? ["-C", cwd, "rev-list", "--left-right", "--count", `${base}...${branch}`] : ["rev-list", "--left-right", "--count", `${base}...${branch}`];
+  const result = runArgsSafe("git", args);
+  if (!result.success) return { ahead: 0, behind: 0 };
+  const parts = result.stdout.split("	");
+  return {
+    behind: parseInt(parts[0] ?? "0", 10) || 0,
+    ahead: parseInt(parts[1] ?? "0", 10) || 0
+  };
+}
+function mergeBranch(cwd, branch, noFf = false) {
+  const args = ["-C", cwd, "merge", branch];
+  if (noFf) args.splice(3, 0, "--no-ff");
+  runArgsInherited("git", args);
+}
+function squashMergeBranch(cwd, branch) {
+  runArgsInherited("git", ["-C", cwd, "merge", "--squash", branch]);
+}
+function rebaseBranch(cwd, onto) {
+  runArgsInherited("git", ["-C", cwd, "rebase", onto]);
+}
+function ffMergeBranch(cwd, branch) {
+  runArgsInherited("git", ["-C", cwd, "merge", "--ff-only", branch]);
+}
+function commitMerge(cwd, message) {
+  runArgsInherited("git", ["-C", cwd, "commit", "-m", message]);
+}
+function renameBranch(oldName, newName) {
+  runArgsInherited("git", ["branch", "-m", oldName, newName]);
+}
+function moveWorktree(oldPath, newPath) {
+  runArgsInherited("git", ["worktree", "move", oldPath, newPath]);
+}
 
 // src/core/config.ts
 var fs = __toESM(require("fs"));
@@ -333,7 +404,9 @@ async function ensureConfig() {
 // src/core/files.ts
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
+var import_minimatch = require("minimatch");
 var GWITINCLUDE_FILE = ".gwitinclude";
+var GLOB_CHARS = /[*?[]/;
 function _parseLines(content) {
   return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
@@ -353,14 +426,33 @@ function copyEntry(src, dest) {
     fs2.copyFileSync(src, dest);
   }
 }
+function isGlobPattern(entry) {
+  return GLOB_CHARS.test(entry);
+}
+function expandGlob(pattern, cwd) {
+  const result = runArgsSafe("git", ["ls-files", "--others", "--ignored", "--exclude-standard"], {
+    cwd
+  });
+  if (!result.success) return [];
+  const files = result.stdout.split("\n").filter((f) => f.length > 0);
+  return files.filter((f) => (0, import_minimatch.minimatch)(f, pattern, { dot: true }));
+}
 function parseGwitInclude(mainPath) {
   const includePath = path2.join(mainPath, GWITINCLUDE_FILE);
   if (!fs2.existsSync(includePath)) return [];
   return _parseLines(fs2.readFileSync(includePath, "utf-8"));
 }
 function copyIncludedFiles(mainPath, worktreePath) {
-  const entries = parseGwitInclude(mainPath);
-  if (entries.length === 0) return [];
+  const rawEntries = parseGwitInclude(mainPath);
+  if (rawEntries.length === 0) return [];
+  const entries = [];
+  for (const entry of rawEntries) {
+    if (isGlobPattern(entry)) {
+      entries.push(...expandGlob(entry, mainPath));
+    } else {
+      entries.push(entry);
+    }
+  }
   const copied = [];
   for (const entry of entries) {
     const entryPath = entry.replace(/\/$/, "");
@@ -394,56 +486,247 @@ function copyIncludedFiles(mainPath, worktreePath) {
   }
   return copied;
 }
+function reverseCopyIncludedFiles(worktreePath, mainPath) {
+  const rawEntries = parseGwitInclude(mainPath);
+  if (rawEntries.length === 0) return [];
+  const entries = [];
+  for (const entry of rawEntries) {
+    if (isGlobPattern(entry)) {
+      entries.push(...expandGlob(entry, worktreePath));
+    } else {
+      entries.push(entry);
+    }
+  }
+  const copied = [];
+  for (const entry of entries) {
+    const entryPath = entry.replace(/\/$/, "");
+    if (path2.isAbsolute(entryPath)) {
+      ui.dim(`  skip ${entry} (absolute path not allowed)`);
+      continue;
+    }
+    const worktreeResolved = path2.resolve(worktreePath);
+    const resolvedSrc = path2.resolve(worktreePath, entryPath);
+    const rel = path2.relative(worktreeResolved, resolvedSrc);
+    if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+      ui.dim(`  skip ${entry} (path escapes repo)`);
+      continue;
+    }
+    const src = resolvedSrc;
+    const dest = path2.resolve(mainPath, entryPath);
+    if (!fs2.existsSync(src)) {
+      ui.dim(`  skip ${entry} (not found in worktree)`);
+      continue;
+    }
+    if (!isGitIgnored(entryPath, mainPath)) {
+      ui.dim(`  skip ${entry} (not gitignored)`);
+      continue;
+    }
+    if (isGitTracked(entryPath, mainPath)) {
+      ui.dim(`  skip ${entry} (tracked by git)`);
+      continue;
+    }
+    copyEntry(src, dest);
+    copied.push(entry);
+  }
+  return copied;
+}
+
+// src/core/snapshot.ts
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var import_crypto = require("crypto");
+var FILES_DIR_NAME = "files";
+var MANIFEST_FILE_NAME = "manifest.json";
+function normalizeRelPath(relPath) {
+  return relPath.replace(/\\/g, "/");
+}
+function tryChmod(filePath, mode) {
+  try {
+    fs3.chmodSync(filePath, mode);
+  } catch {
+  }
+}
+function ensureDir(dirPath) {
+  fs3.mkdirSync(dirPath, { recursive: true, mode: 448 });
+  tryChmod(dirPath, 448);
+}
+function getManifestPath(slug) {
+  return path3.join(getSnapshotDir(slug), MANIFEST_FILE_NAME);
+}
+function getSnapshotFilesDir(slug) {
+  return path3.join(getSnapshotDir(slug), FILES_DIR_NAME);
+}
+function collectEntryFiles(entryPath, mainPath) {
+  const resolvedMain = path3.resolve(mainPath);
+  const resolvedEntry = path3.resolve(entryPath);
+  const relToMain = path3.relative(resolvedMain, resolvedEntry);
+  if (relToMain.startsWith("..") || path3.isAbsolute(relToMain)) {
+    return [];
+  }
+  const stat = fs3.statSync(resolvedEntry);
+  if (stat.isFile()) {
+    return [normalizeRelPath(relToMain)];
+  }
+  const files = [];
+  const stack = [resolvedEntry];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    const entries = fs3.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const childPath = path3.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(childPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        const rel = path3.relative(resolvedMain, childPath);
+        if (!rel.startsWith("..") && !path3.isAbsolute(rel)) {
+          files.push(normalizeRelPath(rel));
+        }
+      }
+    }
+  }
+  return files;
+}
+function writeManifestAtomic(slug, manifest) {
+  const snapshotDir = getSnapshotDir(slug);
+  const manifestPath = getManifestPath(slug);
+  const tmpPath = path3.join(
+    snapshotDir,
+    `${MANIFEST_FILE_NAME}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`
+  );
+  fs3.writeFileSync(tmpPath, JSON.stringify(manifest, null, 2), "utf-8");
+  tryChmod(tmpPath, 384);
+  fs3.renameSync(tmpPath, manifestPath);
+}
+function hashFile(filePath) {
+  const data = fs3.readFileSync(filePath);
+  return (0, import_crypto.createHash)("sha256").update(data).digest("hex");
+}
+function createSnapshot(slug, branch, mainPath, copiedFiles) {
+  const snapshotsDir = getSnapshotsDir();
+  const snapshotDir = getSnapshotDir(slug);
+  const filesDir = getSnapshotFilesDir(slug);
+  ensureDir(snapshotsDir);
+  if (fs3.existsSync(snapshotDir)) {
+    fs3.rmSync(snapshotDir, { recursive: true, force: true });
+  }
+  ensureDir(snapshotDir);
+  ensureDir(filesDir);
+  const relPaths = /* @__PURE__ */ new Set();
+  for (const entry of copiedFiles) {
+    const entryPath = entry.replace(/\/$/, "");
+    if (entryPath.length === 0) continue;
+    const sourcePath = path3.resolve(mainPath, entryPath);
+    if (!fs3.existsSync(sourcePath)) continue;
+    for (const relPath of collectEntryFiles(sourcePath, mainPath)) {
+      relPaths.add(relPath);
+    }
+  }
+  const manifest = {
+    branch,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: {}
+  };
+  for (const relPath of [...relPaths].sort()) {
+    const sourcePath = path3.resolve(mainPath, relPath);
+    if (!fs3.existsSync(sourcePath)) continue;
+    const destPath = path3.join(filesDir, relPath);
+    ensureDir(path3.dirname(destPath));
+    fs3.copyFileSync(sourcePath, destPath);
+    tryChmod(destPath, 384);
+    const stat = fs3.statSync(sourcePath);
+    manifest.files[relPath] = {
+      hash: hashFile(sourcePath),
+      size: stat.size
+    };
+  }
+  writeManifestAtomic(slug, manifest);
+}
+function readSnapshot(slug) {
+  const manifestPath = getManifestPath(slug);
+  if (!fs3.existsSync(manifestPath)) return void 0;
+  try {
+    return JSON.parse(fs3.readFileSync(manifestPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function getSnapshotFilePath(slug, relPath) {
+  const filesDir = path3.resolve(getSnapshotFilesDir(slug));
+  const targetPath = path3.resolve(filesDir, relPath);
+  const relToRoot = path3.relative(filesDir, targetPath);
+  if (relToRoot.startsWith("..") || path3.isAbsolute(relToRoot)) {
+    return void 0;
+  }
+  return fs3.existsSync(targetPath) ? targetPath : void 0;
+}
+function deleteSnapshot(slug) {
+  const snapshotDir = getSnapshotDir(slug);
+  if (!fs3.existsSync(snapshotDir)) return;
+  fs3.rmSync(snapshotDir, { recursive: true, force: true });
+}
+function renameSnapshot(oldSlug, newSlug) {
+  const oldDir = getSnapshotDir(oldSlug);
+  const newDir = getSnapshotDir(newSlug);
+  if (!fs3.existsSync(oldDir)) return;
+  ensureDir(getSnapshotsDir());
+  if (fs3.existsSync(newDir)) {
+    fs3.rmSync(newDir, { recursive: true, force: true });
+  }
+  fs3.renameSync(oldDir, newDir);
+}
 
 // src/core/ports.ts
 var net = __toESM(require("net"));
 
 // src/core/registry.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var MAX_RETRIES = 3;
 var RETRY_DELAY_MS = 100;
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 async function writeRegistry(registry) {
   const registryPath = getRegistryPath();
   const gwitDir = getGwitDir();
-  if (!fs3.existsSync(gwitDir)) {
-    fs3.mkdirSync(gwitDir, { recursive: true, mode: 448 });
+  if (!fs4.existsSync(gwitDir)) {
+    fs4.mkdirSync(gwitDir, { recursive: true, mode: 448 });
   }
-  const tmpPath = path3.join(
+  const tmpPath = path4.join(
     gwitDir,
     `worktrees.json.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`
   );
-  fs3.writeFileSync(tmpPath, JSON.stringify(registry, null, 2), "utf-8");
+  fs4.writeFileSync(tmpPath, JSON.stringify(registry, null, 2), "utf-8");
   try {
-    fs3.chmodSync(tmpPath, 384);
+    fs4.chmodSync(tmpPath, 384);
   } catch {
   }
   for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
     try {
-      fs3.renameSync(tmpPath, registryPath);
+      fs4.renameSync(tmpPath, registryPath);
       return;
     } catch {
       if (attempt < MAX_RETRIES) await sleep(RETRY_DELAY_MS);
     }
   }
   try {
-    fs3.unlinkSync(tmpPath);
+    fs4.unlinkSync(tmpPath);
   } catch {
   }
   throw new GwitError("Failed to write worktree registry after multiple retries.");
 }
 function readRegistry() {
   const registryPath = getRegistryPath();
-  if (!fs3.existsSync(registryPath)) return {};
+  if (!fs4.existsSync(registryPath)) return {};
   try {
-    return JSON.parse(fs3.readFileSync(registryPath, "utf-8"));
+    return JSON.parse(fs4.readFileSync(registryPath, "utf-8"));
   } catch {
     const backupPath = `${registryPath}.bak`;
     try {
-      fs3.copyFileSync(registryPath, backupPath);
+      fs4.copyFileSync(registryPath, backupPath);
     } catch {
     }
     console.warn(`\u26A0 Corrupted registry backed up to ${backupPath}. Starting fresh.`);
@@ -484,10 +767,10 @@ function listWorktreeEntries(mainPath) {
 // src/core/ports.ts
 var MAX_PORT_SCAN = 100;
 function _isPortFree(port) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve4) => {
     const server = net.createServer();
-    server.once("error", () => server.close(() => resolve2(false)));
-    server.once("listening", () => server.close(() => resolve2(true)));
+    server.once("error", () => server.close(() => resolve4(false)));
+    server.once("listening", () => server.close(() => resolve4(true)));
     server.listen(port, "127.0.0.1");
   });
 }
@@ -523,8 +806,8 @@ function buildEnvironment(branch, slug, port, worktreePath, mainPath, index) {
 }
 
 // src/core/hooks.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 var import_child_process2 = require("child_process");
 var GWITCOMMAND_FILE = ".gwitcommand";
 var GWITCLEANUP_FILE = ".gwitcleanup";
@@ -532,9 +815,9 @@ function _parseHookLines(content) {
   return content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
 }
 function readHookFile(mainPath, filename) {
-  const filePath = path4.join(mainPath, filename);
-  if (!fs4.existsSync(filePath)) return [];
-  return _parseHookLines(fs4.readFileSync(filePath, "utf-8"));
+  const filePath = path5.join(mainPath, filename);
+  if (!fs5.existsSync(filePath)) return [];
+  return _parseHookLines(fs5.readFileSync(filePath, "utf-8"));
 }
 function executeCommands(commands, worktreePath, env, stopOnError, label) {
   const mergedEnv = { ...process.env, ...env };
@@ -624,6 +907,10 @@ async function createCommand(branch, options) {
     );
   }
   assertBranchResolvable(branch, isNew);
+  if (!isNew && !branchExistsLocal(branch)) {
+    ui.step("Fetching from origin\u2026");
+    fetchOrigin();
+  }
   const config = await ensureConfig();
   const mainPath = getMainWorktreePath();
   const slug = toSlug(branch);
@@ -633,6 +920,7 @@ async function createCommand(branch, options) {
   ui.success(`Worktree ready at ${ui.bold(worktreePath)}`);
   const copied = copyIncludedFiles(mainPath, worktreePath);
   if (copied.length > 0) {
+    createSnapshot(slug, branch, mainPath, copied);
     ui.success(`Copied ${copied.length} file${copied.length === 1 ? "" : "s"} from .gwitinclude`);
     copied.forEach((f) => ui.dim(`  ${f}`));
   }
@@ -696,7 +984,7 @@ function listCommand() {
 }
 
 // src/commands/remove.ts
-var fs5 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 function removeUnregisteredWorktree(branch, force) {
   const worktrees = listWorktrees();
   const match = worktrees.find((w) => w.branch === branch);
@@ -726,7 +1014,7 @@ async function removeCommand(branch, options) {
     return;
   }
   const worktreePath = entry.path;
-  if (!force && fs5.existsSync(worktreePath) && hasUncommittedChanges(worktreePath)) {
+  if (!force && fs6.existsSync(worktreePath) && hasUncommittedChanges(worktreePath)) {
     throw new GwitError(
       `Worktree '${branch}' has uncommitted changes.`,
       `Use 'gwit remove ${branch} --force' to remove anyway, or commit first.`
@@ -742,13 +1030,14 @@ async function removeCommand(branch, options) {
   );
   runCleanupHooks(mainPath, worktreePath, env);
   ui.step(`Removing worktree at ${worktreePath}\u2026`);
-  if (fs5.existsSync(worktreePath)) {
+  if (fs6.existsSync(worktreePath)) {
     removeWorktree(worktreePath, force);
   } else {
     runArgs("git", ["worktree", "prune"]);
     ui.dim("  (directory not found \u2014 pruned git bookkeeping)");
   }
   await removeWorktreeEntry(mainPath, branch);
+  deleteSnapshot(entry.slug);
   ui.success(`Removed worktree for '${branch}' (port ${entry.port} freed)`);
 }
 
@@ -809,8 +1098,8 @@ function configSetCommand(key, value) {
 }
 
 // src/commands/init.ts
-var fs6 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var import_inquirer2 = __toESM(require("inquirer"));
 var GWITINCLUDE_FILE2 = ".gwitinclude";
 var GWITCOMMAND_FILE2 = ".gwitcommand";
@@ -839,23 +1128,23 @@ var CLEANUP_HEADER = [
   "# All $GWIT_* variables are available."
 ].join("\n");
 function _detectAppName(mainPath) {
-  const pkgPath = path5.join(mainPath, "package.json");
-  if (fs6.existsSync(pkgPath)) {
+  const pkgPath = path6.join(mainPath, "package.json");
+  if (fs7.existsSync(pkgPath)) {
     try {
-      const pkg2 = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+      const pkg2 = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
       if (pkg2.name && pkg2.name.trim().length > 0) {
         return pkg2.name.replace(/^@[^/]+\//, "").trim();
       }
     } catch {
     }
   }
-  return path5.basename(mainPath);
+  return path6.basename(mainPath);
 }
 function _detectPackageManager(mainPath) {
-  if (fs6.existsSync(path5.join(mainPath, "bun.lockb"))) return "bun";
-  if (fs6.existsSync(path5.join(mainPath, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs6.existsSync(path5.join(mainPath, "yarn.lock"))) return "yarn";
-  if (fs6.existsSync(path5.join(mainPath, "package.json"))) return "npm";
+  if (fs7.existsSync(path6.join(mainPath, "bun.lockb"))) return "bun";
+  if (fs7.existsSync(path6.join(mainPath, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs7.existsSync(path6.join(mainPath, "yarn.lock"))) return "yarn";
+  if (fs7.existsSync(path6.join(mainPath, "package.json"))) return "npm";
   return null;
 }
 function scanGitignored(mainPath) {
@@ -868,8 +1157,8 @@ function scanGitignored(mainPath) {
   return result.stdout.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
 }
 function writeHookFile(filePath, content, force) {
-  if (fs6.existsSync(filePath) && !force) return "skipped";
-  fs6.writeFileSync(filePath, content, "utf-8");
+  if (fs7.existsSync(filePath) && !force) return "skipped";
+  fs7.writeFileSync(filePath, content, "utf-8");
   return "written";
 }
 async function collectCommands(firstMessage, continueMessage) {
@@ -1074,7 +1363,7 @@ async function initCommand(options) {
   const detectedAppName = _detectAppName(mainPath);
   const detectedPm = _detectPackageManager(mainPath);
   console.log();
-  ui.info(`Setting up gwit for ${ui.bold(path5.basename(mainPath))}`);
+  ui.info(`Setting up gwit for ${ui.bold(path6.basename(mainPath))}`);
   if (!options.force) {
     ui.dim("  Existing files are skipped \u2014 use --force to overwrite.");
   }
@@ -1091,7 +1380,7 @@ async function initCommand(options) {
     { name: GWITCLEANUP_FILE2, content: _buildCleanupContent(sel.appName, sel) }
   ];
   for (const { name, content } of files) {
-    const result = writeHookFile(path5.join(mainPath, name), content, options.force);
+    const result = writeHookFile(path6.join(mainPath, name), content, options.force);
     if (result === "written") {
       ui.success(`  ${name}`);
     } else {
@@ -1127,7 +1416,117 @@ function openCommand(branch, options) {
 }
 
 // src/commands/sync.ts
-var fs7 = __toESM(require("fs"));
+var fs9 = __toESM(require("fs"));
+
+// src/core/merge.ts
+var fs8 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+function normalizeRelPath2(relPath) {
+  return relPath.replace(/\\/g, "/");
+}
+function copyFileToMain(worktreeFile, mainFile) {
+  fs8.mkdirSync(path7.dirname(mainFile), { recursive: true });
+  fs8.copyFileSync(worktreeFile, mainFile);
+}
+function isExistingFile(filePath) {
+  return fs8.existsSync(filePath) && fs8.statSync(filePath).isFile();
+}
+function isBinaryFile(filePath) {
+  const fd = fs8.openSync(filePath, "r");
+  const buffer = Buffer.alloc(8192);
+  try {
+    const bytesRead = fs8.readSync(fd, buffer, 0, buffer.length, 0);
+    for (let i = 0; i < bytesRead; i++) {
+      if (buffer[i] === 0) return true;
+    }
+    return false;
+  } finally {
+    fs8.closeSync(fd);
+  }
+}
+function runGitMergeFile(mainFile, snapshotFile, worktreeFile, branch) {
+  const result = runArgsWithExitCode("git", [
+    "merge-file",
+    "-L",
+    "main",
+    "-L",
+    "base",
+    "-L",
+    branch,
+    mainFile,
+    snapshotFile,
+    worktreeFile
+  ]);
+  return result.exitCode > 0;
+}
+function mergeBackIncludedFiles(worktreePath, mainPath, slug) {
+  const result = {
+    copied: [],
+    merged: [],
+    conflicts: [],
+    skipped: [],
+    binarySkipped: []
+  };
+  const manifest = readSnapshot(slug);
+  if (!manifest) return result;
+  const relPaths = Object.keys(manifest.files).sort();
+  for (const rawRelPath of relPaths) {
+    const relPath = normalizeRelPath2(rawRelPath);
+    const base = manifest.files[relPath];
+    if (!base) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    if (!isGitIgnored(relPath, mainPath) || isGitTracked(relPath, mainPath)) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    const mainFile = path7.resolve(mainPath, relPath);
+    const worktreeFile = path7.resolve(worktreePath, relPath);
+    const snapshotFile = getSnapshotFilePath(slug, relPath);
+    if (!isExistingFile(mainFile)) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    if (!isExistingFile(worktreeFile)) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    if (!snapshotFile || !isExistingFile(snapshotFile)) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    const baseHash = base.hash;
+    const mainHash = hashFile(mainFile);
+    const worktreeHash = hashFile(worktreeFile);
+    if (baseHash === mainHash && baseHash === worktreeHash) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    if (baseHash === mainHash) {
+      copyFileToMain(worktreeFile, mainFile);
+      result.copied.push(relPath);
+      continue;
+    }
+    if (baseHash === worktreeHash || mainHash === worktreeHash) {
+      result.skipped.push(relPath);
+      continue;
+    }
+    if (isBinaryFile(mainFile) || isBinaryFile(worktreeFile) || isBinaryFile(snapshotFile)) {
+      result.binarySkipped.push(relPath);
+      continue;
+    }
+    const hasConflicts = runGitMergeFile(mainFile, snapshotFile, worktreeFile, manifest.branch);
+    if (hasConflicts) {
+      result.conflicts.push(relPath);
+    } else {
+      result.merged.push(relPath);
+    }
+  }
+  return result;
+}
+
+// src/commands/sync.ts
 function detectCurrentBranch(mainPath) {
   const currentRoot = getRepoRoot();
   if (currentRoot === mainPath) {
@@ -1149,7 +1548,45 @@ function detectCurrentBranch(mainPath) {
   }
   return current.branch;
 }
-function syncCommand(branch) {
+function logFileList(files) {
+  files.forEach((f) => ui.dim(`  ${f}`));
+}
+function reportBackResult(result) {
+  if (result.copied.length > 0) {
+    ui.success(
+      `Copied ${result.copied.length} worktree-only file${result.copied.length === 1 ? "" : "s"}`
+    );
+    logFileList(result.copied);
+  }
+  if (result.merged.length > 0) {
+    ui.success(
+      `Merged ${result.merged.length} file${result.merged.length === 1 ? "" : "s"} cleanly`
+    );
+    logFileList(result.merged);
+  }
+  if (result.conflicts.length > 0) {
+    ui.warn(
+      `Conflicts in ${result.conflicts.length} file${result.conflicts.length === 1 ? "" : "s"} (markers written to main)`
+    );
+    logFileList(result.conflicts);
+  }
+  if (result.binarySkipped.length > 0) {
+    ui.warn(
+      `Skipped ${result.binarySkipped.length} binary file${result.binarySkipped.length === 1 ? "" : "s"} (manual resolution required)`
+    );
+    logFileList(result.binarySkipped);
+  }
+  if (result.skipped.length > 0) {
+    ui.dim(
+      `  skipped ${result.skipped.length} unchanged/main-only file${result.skipped.length === 1 ? "" : "s"}`
+    );
+  }
+  const changed = result.copied.length + result.merged.length + result.conflicts.length;
+  if (changed === 0 && result.binarySkipped.length === 0) {
+    ui.info("Nothing to sync back \u2014 no snapshot-tracked files changed.");
+  }
+}
+function syncCommand(branch, options = {}) {
   if (!isGitRepo()) {
     throw new GwitError(
       "Not a git repository.",
@@ -1165,26 +1602,403 @@ function syncCommand(branch) {
       `Run 'gwit list' to see active worktrees.`
     );
   }
-  if (!fs7.existsSync(entry.path)) {
+  if (!fs9.existsSync(entry.path)) {
     throw new GwitError(
       `Worktree path no longer exists: ${entry.path}`,
       `Run 'gwit remove ${targetBranch}' to clean up the stale registry entry.`
     );
   }
+  if (options.back) {
+    ui.step(`Syncing .gwitinclude back to main from ${entry.path}\u2026`);
+    const snapshot = readSnapshot(entry.slug);
+    if (!snapshot) {
+      ui.warn(`No snapshot found for '${targetBranch}' \u2014 falling back to direct copy.`);
+      const copiedBack = reverseCopyIncludedFiles(entry.path, mainPath);
+      if (copiedBack.length > 0) {
+        ui.success(`Synced ${copiedBack.length} file${copiedBack.length === 1 ? "" : "s"} back`);
+        logFileList(copiedBack);
+      } else {
+        ui.info("Nothing to sync back \u2014 no .gwitinclude entries were copied.");
+      }
+      return;
+    }
+    const result = mergeBackIncludedFiles(entry.path, mainPath, entry.slug);
+    reportBackResult(result);
+    return;
+  }
   ui.step(`Syncing .gwitinclude into ${entry.path}\u2026`);
   const copied = copyIncludedFiles(mainPath, entry.path);
   if (copied.length > 0) {
     ui.success(`Synced ${copied.length} file${copied.length === 1 ? "" : "s"}`);
-    copied.forEach((f) => ui.dim(`  ${f}`));
+    logFileList(copied);
   } else {
     ui.info("Nothing to sync \u2014 no .gwitinclude entries were copied.");
   }
 }
 
+// src/commands/merge.ts
+var fs10 = __toESM(require("fs"));
+function executeMerge(mainPath, worktreePath, branch, target, options) {
+  try {
+    if (options.squash) {
+      ui.step(`Squash merging '${branch}' into '${target}'\u2026`);
+      squashMergeBranch(mainPath, branch);
+      commitMerge(mainPath, `Squash merge branch '${branch}'`);
+    } else if (options.rebase) {
+      ui.step(`Rebasing '${branch}' onto '${target}'\u2026`);
+      rebaseBranch(worktreePath, target);
+      ui.step(`Fast-forwarding '${target}' to '${branch}'\u2026`);
+      ffMergeBranch(mainPath, branch);
+    } else {
+      ui.step(`Merging '${branch}' into '${target}'\u2026`);
+      mergeBranch(mainPath, branch, options.noFf ?? false);
+    }
+  } catch {
+    throw new GwitError(
+      `Merge conflict while merging '${branch}' into '${target}'.`,
+      `Resolve conflicts in ${mainPath}, then run: git merge --continue`
+    );
+  }
+}
+async function cleanupWorktree(mainPath, worktreePath, branch, port) {
+  const entry = getWorktreeEntry(mainPath, branch);
+  if (entry) {
+    const env = buildEnvironment(
+      entry.branch,
+      entry.slug,
+      entry.port,
+      worktreePath,
+      mainPath,
+      entry.index
+    );
+    runCleanupHooks(mainPath, worktreePath, env);
+  }
+  ui.step(`Removing worktree at ${worktreePath}\u2026`);
+  if (fs10.existsSync(worktreePath)) {
+    removeWorktree(worktreePath, true);
+  } else {
+    runArgs("git", ["worktree", "prune"]);
+  }
+  await removeWorktreeEntry(mainPath, branch);
+  ui.success(`Cleaned up worktree for '${branch}' (port ${port} freed)`);
+}
+function syncBackFiles(worktreePath, mainPath, slug, branch) {
+  const snapshot = readSnapshot(slug);
+  if (!snapshot) {
+    ui.warn(`No snapshot found for '${branch}' \u2014 falling back to direct copy.`);
+    const copied = reverseCopyIncludedFiles(worktreePath, mainPath);
+    if (copied.length > 0) {
+      ui.success(`Synced ${copied.length} file${copied.length === 1 ? "" : "s"} back`);
+      copied.forEach((f) => ui.dim(`  ${f}`));
+    } else {
+      ui.dim("  No .gwitinclude files to sync back");
+    }
+    return;
+  }
+  const result = mergeBackIncludedFiles(worktreePath, mainPath, slug);
+  const changed = result.copied.length + result.merged.length + result.conflicts.length;
+  if (result.copied.length > 0) {
+    ui.success(
+      `Copied ${result.copied.length} worktree-only file${result.copied.length === 1 ? "" : "s"}`
+    );
+    result.copied.forEach((f) => ui.dim(`  ${f}`));
+  }
+  if (result.merged.length > 0) {
+    ui.success(
+      `Merged ${result.merged.length} file${result.merged.length === 1 ? "" : "s"} cleanly`
+    );
+    result.merged.forEach((f) => ui.dim(`  ${f}`));
+  }
+  if (result.conflicts.length > 0) {
+    ui.warn(
+      `Conflicts in ${result.conflicts.length} file${result.conflicts.length === 1 ? "" : "s"} (markers written to main)`
+    );
+    result.conflicts.forEach((f) => ui.dim(`  ${f}`));
+  }
+  if (result.binarySkipped.length > 0) {
+    ui.warn(
+      `Skipped ${result.binarySkipped.length} binary file${result.binarySkipped.length === 1 ? "" : "s"} (manual resolution required)`
+    );
+    result.binarySkipped.forEach((f) => ui.dim(`  ${f}`));
+  }
+  if (changed === 0 && result.binarySkipped.length === 0) {
+    ui.dim("  No .gwitinclude files to sync back");
+  }
+}
+async function mergeCommand(branch, options) {
+  if (!isGitRepo()) {
+    throw new GwitError(
+      "Not a git repository.",
+      "Run gwit merge from inside a git repo (or any of its worktrees)."
+    );
+  }
+  const mainPath = getMainWorktreePath();
+  const entry = getWorktreeEntry(mainPath, branch);
+  if (!entry) {
+    throw new GwitError(
+      `No gwit worktree found for '${branch}'.`,
+      `Run 'gwit list' to see active worktrees.`
+    );
+  }
+  if (!fs10.existsSync(entry.path)) {
+    throw new GwitError(
+      `Worktree path no longer exists: ${entry.path}`,
+      `Run 'gwit remove ${branch}' to clean up the stale registry entry.`
+    );
+  }
+  if (hasUncommittedChanges(entry.path)) {
+    throw new GwitError(
+      `Worktree for '${branch}' has uncommitted changes.`,
+      "Commit or stash changes in the worktree first, then retry."
+    );
+  }
+  const target = options.into ?? getDefaultBranch();
+  ui.info(`Target branch: ${ui.bold(target)}`);
+  if (options.syncBack !== false) {
+    ui.step("Syncing .gwitinclude files back to main\u2026");
+    syncBackFiles(entry.path, mainPath, entry.slug, entry.branch);
+  }
+  executeMerge(mainPath, entry.path, branch, target, options);
+  ui.success(`Merged '${branch}' into '${target}'`);
+  if (options.cleanup) {
+    await cleanupWorktree(mainPath, entry.path, branch, entry.port);
+  }
+}
+
+// src/commands/status.ts
+var fs11 = __toESM(require("fs"));
+
+// src/core/gh.ts
+function aggregateChecks(rollup) {
+  if (!rollup || rollup.length === 0) return null;
+  let hasPending = false;
+  for (const check of rollup) {
+    const conclusion = check.conclusion ?? check.state;
+    if (conclusion === "FAILURE" || conclusion === "ERROR" || conclusion === "ACTION_REQUIRED") {
+      return "fail";
+    }
+    if (conclusion === "PENDING" || check.status === "IN_PROGRESS" || check.status === "QUEUED") {
+      hasPending = true;
+    }
+  }
+  return hasPending ? "pending" : "pass";
+}
+function isGhAvailable() {
+  return runArgsSafe("gh", ["--version"]).success;
+}
+function getPrInfo(branch) {
+  const result = runArgsSafe("gh", [
+    "pr",
+    "view",
+    branch,
+    "--json",
+    "number,state,isDraft,statusCheckRollup"
+  ]);
+  if (!result.success || result.stdout.length === 0) return null;
+  try {
+    const data = JSON.parse(result.stdout);
+    if (typeof data.number !== "number" || typeof data.state !== "string") return null;
+    return {
+      number: data.number,
+      state: data.state,
+      isDraft: data.isDraft ?? false,
+      checksStatus: aggregateChecks(data.statusCheckRollup)
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/status.ts
+function buildRow(branch, entryPath, port, defaultBranch, ghAvailable) {
+  const exists = fs11.existsSync(entryPath);
+  const { ahead, behind } = exists ? getAheadBehind(branch, defaultBranch, entryPath) : { ahead: 0, behind: 0 };
+  const dirty = exists ? hasUncommittedChanges(entryPath) : false;
+  let pr = "\u2014";
+  if (ghAvailable) {
+    const info = getPrInfo(branch);
+    if (info) {
+      const draft = info.isDraft ? " draft" : "";
+      const checks = info.checksStatus ? ` (checks: ${info.checksStatus})` : "";
+      pr = `#${info.number} ${info.state.toLowerCase()}${draft}${checks}`;
+    }
+  }
+  return { branch, path: entryPath, port, ahead, behind, dirty, pr };
+}
+function printTable2(rows) {
+  const headers = ["Branch", "Port", "Ahead/Behind", "Changes", "PR"];
+  const formatted = rows.map((r) => [
+    r.branch,
+    String(r.port),
+    `+${r.ahead} / -${r.behind}`,
+    r.dirty ? "dirty" : "clean",
+    r.pr
+  ]);
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...formatted.map((row) => (row[i] ?? "").length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i] ?? 0)).join("  ");
+  console.log(`  ${ui.bold(headerLine)}`);
+  for (const row of formatted) {
+    const line = row.map((cell, i) => (cell ?? "").padEnd(widths[i] ?? 0)).join("  ");
+    console.log(`  ${line}`);
+  }
+}
+function statusCommand(options) {
+  if (!isGitRepo()) {
+    throw new GwitError(
+      "Not a git repository.",
+      "Run gwit status from inside a git repo (or any of its worktrees)."
+    );
+  }
+  const mainPath = getMainWorktreePath();
+  const entries = listWorktreeEntries(mainPath);
+  if (entries.length === 0) {
+    ui.info("No active gwit worktrees.");
+    return;
+  }
+  const defaultBranch = getDefaultBranch();
+  const ghAvail = isGhAvailable();
+  const rows = entries.map((e) => buildRow(e.branch, e.path, e.port, defaultBranch, ghAvail));
+  if (options.json) {
+    console.log(JSON.stringify(rows, null, 2));
+    return;
+  }
+  console.log();
+  printTable2(rows);
+  console.log();
+}
+
+// src/commands/sweep.ts
+var fs12 = __toESM(require("fs"));
+var import_inquirer3 = __toESM(require("inquirer"));
+function isSweepable(branch, defaultBranch, ghAvailable) {
+  if (isBranchMerged(branch, defaultBranch)) return true;
+  if (ghAvailable) {
+    const pr = getPrInfo(branch);
+    if (pr && (pr.state === "MERGED" || pr.state === "CLOSED")) return true;
+  }
+  return false;
+}
+async function sweepEntry(entry, mainPath) {
+  const env = buildEnvironment(
+    entry.branch,
+    entry.slug,
+    entry.port,
+    entry.path,
+    mainPath,
+    entry.index
+  );
+  runCleanupHooks(mainPath, entry.path, env);
+  if (fs12.existsSync(entry.path)) {
+    removeWorktree(entry.path, true);
+  } else {
+    runArgs("git", ["worktree", "prune"]);
+  }
+  await removeWorktreeEntry(mainPath, entry.branch);
+  ui.success(`Removed '${entry.branch}' (port ${entry.port} freed)`);
+}
+async function sweepCommand(options) {
+  if (!isGitRepo()) {
+    throw new GwitError(
+      "Not a git repository.",
+      "Run gwit sweep from inside a git repo (or any of its worktrees)."
+    );
+  }
+  const mainPath = getMainWorktreePath();
+  const entries = listWorktreeEntries(mainPath);
+  if (entries.length === 0) {
+    ui.info("No active gwit worktrees to sweep.");
+    return;
+  }
+  const defaultBranch = getDefaultBranch();
+  const ghAvail = isGhAvailable();
+  const sweepable = entries.filter((e) => isSweepable(e.branch, defaultBranch, ghAvail));
+  if (sweepable.length === 0) {
+    ui.info("No merged worktrees found to sweep.");
+    return;
+  }
+  console.log();
+  ui.info(`Found ${sweepable.length} merged worktree${sweepable.length === 1 ? "" : "s"}:`);
+  for (const entry of sweepable) {
+    ui.dim(`  ${entry.branch} (port ${entry.port})`);
+  }
+  console.log();
+  if (options.dryRun) {
+    ui.info("Dry run \u2014 no worktrees were removed.");
+    return;
+  }
+  if (!options.force) {
+    const { confirm } = await import_inquirer3.default.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: `Remove ${sweepable.length} worktree${sweepable.length === 1 ? "" : "s"}?`,
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      ui.info("Sweep cancelled.");
+      return;
+    }
+  }
+  for (const entry of sweepable) {
+    await sweepEntry(entry, mainPath);
+  }
+  ui.success(`Swept ${sweepable.length} worktree${sweepable.length === 1 ? "" : "s"}`);
+}
+
+// src/commands/rename.ts
+async function renameCommand(oldBranch, newBranch) {
+  if (!isGitRepo()) {
+    throw new GwitError(
+      "Not a git repository.",
+      "Run gwit rename from inside a git repo (or any of its worktrees)."
+    );
+  }
+  const mainPath = getMainWorktreePath();
+  const entry = getWorktreeEntry(mainPath, oldBranch);
+  if (!entry) {
+    throw new GwitError(
+      `No gwit worktree found for '${oldBranch}'.`,
+      `Run 'gwit list' to see active worktrees.`
+    );
+  }
+  const existingNew = getWorktreeEntry(mainPath, newBranch);
+  if (existingNew) {
+    throw new GwitError(
+      `A worktree already exists for '${newBranch}'.`,
+      `Remove it first: gwit remove ${newBranch}`
+    );
+  }
+  ui.step(`Renaming branch '${oldBranch}' \u2192 '${newBranch}'\u2026`);
+  renameBranch(oldBranch, newBranch);
+  const oldSlug = entry.slug;
+  const newSlug = toSlug(newBranch);
+  let newPath = entry.path;
+  if (oldSlug !== newSlug) {
+    const config = loadConfig();
+    newPath = getWorktreePath(mainPath, config.location, newSlug);
+    ui.step(`Moving worktree to ${newPath}\u2026`);
+    moveWorktree(entry.path, newPath);
+    renameSnapshot(oldSlug, newSlug);
+  }
+  await removeWorktreeEntry(mainPath, oldBranch);
+  await addWorktreeEntry(mainPath, {
+    ...entry,
+    branch: newBranch,
+    slug: newSlug,
+    path: newPath
+  });
+  ui.success(`Renamed '${oldBranch}' \u2192 '${newBranch}'`);
+  if (oldSlug !== newSlug) {
+    ui.info(`Slug   ${ui.bold(oldSlug)} \u2192 ${ui.bold(newSlug)}`);
+    ui.info(`Path   ${ui.bold(newPath)}`);
+  }
+}
+
 // src/index.ts
-var pkg = JSON.parse(
-  fs8.readFileSync(path6.join(__dirname, "..", "package.json"), "utf-8")
-);
+var pkg = JSON.parse(fs13.readFileSync(path8.join(__dirname, "..", "package.json"), "utf-8"));
 var program = new import_commander.Command();
 program.name("gwit").description("Fully isolated git worktrees for parallel development").version(pkg.version);
 program.argument("[branch]", "Branch name (local or remote)").option("-b", "Create a new branch from HEAD").option("--editor <name>", "Override editor for this invocation").option("--no-editor", "Skip opening editor").option("--no-commands", "Skip .gwitcommand execution").action(async (branch, options) => {
@@ -1216,8 +2030,20 @@ configCmd.action(() => {
 program.command("open <branch>").description("Re-open the editor for an existing gwit worktree").option("--editor <name>", "Override editor for this invocation").action((branch, options) => {
   openCommand(branch, options);
 });
-program.command("sync [branch]").description("Re-copy .gwitinclude files into an existing worktree").action((branch) => {
-  syncCommand(branch);
+program.command("sync [branch]").description("Sync .gwitinclude files into a worktree or back to main").option("--back", "Three-way merge .gwitinclude files back to main").action((branch, options) => {
+  syncCommand(branch, options);
+});
+program.command("merge <branch>").description("Merge a worktree branch back into the target branch").option("--into <target>", "Target branch (default: repo default branch)").option("--squash", "Squash all commits into one before merging").option("--rebase", "Rebase feature onto target, then fast-forward").option("--no-ff", "Force a merge commit even when fast-forward is possible").option("--cleanup", "Remove worktree after successful merge").option("--no-sync-back", "Skip reverse-copying .gwitinclude files").action(async (branch, options) => {
+  await mergeCommand(branch, options);
+});
+program.command("status").description("Show status of all active gwit worktrees").option("--json", "Output as JSON").action((options) => {
+  statusCommand(options);
+});
+program.command("sweep").description("Remove worktrees whose branches are merged").option("--dry-run", "Show what would be removed without removing").option("--force", "Skip confirmation prompt").action(async (options) => {
+  await sweepCommand(options);
+});
+program.command("rename <old-branch> <new-branch>").description("Rename a worktree branch").action(async (oldBranch, newBranch) => {
+  await renameCommand(oldBranch, newBranch);
 });
 program.parseAsync(process.argv).catch((err) => {
   if (err instanceof GwitError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shivanshshrivas/gwit",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Fully isolated git worktrees for parallel development",
   "license": "MIT",
   "engines": {
@@ -21,22 +21,30 @@
     "test:unit": "vitest run tests/unit",
     "test:integration": "vitest run tests/integration",
     "lint": "eslint src tests --ext .ts",
-    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\""
+    "lint:maintainability": "eslint -c eslint.maintainability.cjs src/",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\""
   },
   "dependencies": {
     "commander": "^12.1.0",
-    "inquirer": "^8.2.6"
+    "inquirer": "^8.2.6",
+    "minimatch": "^10.2.4"
   },
   "devDependencies": {
+    "@eslint/js": "^9.39.3",
     "@types/inquirer": "^8.2.10",
+    "@types/minimatch": "^5.1.2",
     "@types/node": "^20.0.0",
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "eslint": "^8.57.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jsdoc": "^61.7.1",
     "prettier": "^3.2.0",
     "tsup": "^8.0.0",
     "tsx": "^4.7.0",
     "typescript": "^5.4.0",
+    "typescript-eslint": "^8.56.1",
     "vitest": "^1.6.0"
   }
 }