webmux 0.11.0 → 0.13.0

package/bin/webmux.js

@@ -47,6 +47,401 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
+// backend/src/adapters/git.ts
+import { rmSync } from "fs";
+import { resolve } from "path";
+function runGit(args, cwd) {
+  const result = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0) {
+    const stderr = new TextDecoder().decode(result.stderr).trim();
+    throw new Error(`git ${args.join(" ")} failed: ${stderr || `exit ${result.exitCode}`}`);
+  }
+  return new TextDecoder().decode(result.stdout).trim();
+}
+function tryRunGit(args, cwd) {
+  const result = Bun.spawnSync(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0) {
+    return {
+      ok: false,
+      stderr: new TextDecoder().decode(result.stderr).trim()
+    };
+  }
+  return {
+    ok: true,
+    stdout: new TextDecoder().decode(result.stdout).trim()
+  };
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isRegisteredWorktree(entries, worktreePath) {
+  const resolvedPath = resolve(worktreePath);
+  return entries.some((entry) => resolve(entry.path) === resolvedPath);
+}
+function removeDirectory(path) {
+  rmSync(path, {
+    recursive: true,
+    force: true
+  });
+}
+function currentCheckoutRef(cwd) {
+  const symbolicRef = tryRunGit(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
+  if (symbolicRef.ok && symbolicRef.stdout.length > 0) {
+    return {
+      ref: symbolicRef.stdout,
+      branch: symbolicRef.stdout
+    };
+  }
+  return {
+    ref: runGit(["rev-parse", "--verify", "HEAD"], cwd),
+    branch: null
+  };
+}
+function resolveWorktreeRoot(cwd) {
+  const output = runGit(["rev-parse", "--show-toplevel"], cwd);
+  return resolve(cwd, output);
+}
+function resolveWorktreeGitDir(cwd) {
+  const output = runGit(["rev-parse", "--git-dir"], cwd);
+  return resolve(cwd, output);
+}
+function parseGitWorktreePorcelain(output) {
+  const entries = [];
+  let current = null;
+  const flush = () => {
+    if (current?.path)
+      entries.push(current);
+    current = null;
+  };
+  for (const rawLine of output.split(`
+`)) {
+    const line = rawLine.trimEnd();
+    if (!line) {
+      flush();
+      continue;
+    }
+    if (line.startsWith("worktree ")) {
+      flush();
+      current = {
+        path: line.slice("worktree ".length),
+        branch: null,
+        head: null,
+        detached: false,
+        bare: false
+      };
+      continue;
+    }
+    if (!current)
+      continue;
+    if (line.startsWith("branch ")) {
+      current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
+      continue;
+    }
+    if (line.startsWith("HEAD ")) {
+      current.head = line.slice("HEAD ".length);
+      continue;
+    }
+    if (line === "detached") {
+      current.detached = true;
+      continue;
+    }
+    if (line === "bare") {
+      current.bare = true;
+    }
+  }
+  flush();
+  return entries;
+}
+function listGitWorktrees(cwd) {
+  const output = runGit(["worktree", "list", "--porcelain"], cwd);
+  return parseGitWorktreePorcelain(output);
+}
+function listLocalGitBranches(cwd) {
+  const output = runGit(["for-each-ref", "--format=%(refname:short)", "refs/heads"], cwd);
+  return output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function readGitWorktreeStatus(cwd) {
+  const dirtyOutput = runGit(["status", "--porcelain"], cwd);
+  const commit = tryRunGit(["rev-parse", "HEAD"], cwd);
+  const ahead = tryRunGit(["rev-list", "--count", "@{upstream}..HEAD"], cwd);
+  return {
+    dirty: dirtyOutput.length > 0,
+    aheadCount: ahead.ok ? parseInt(ahead.stdout, 10) || 0 : 0,
+    currentCommit: commit.ok && commit.stdout.length > 0 ? commit.stdout : null
+  };
+}
+function removeGitWorktree(opts, deps = {}) {
+  const args = ["worktree", "remove"];
+  if (opts.force)
+    args.push("--force");
+  args.push(opts.worktreePath);
+  const result = (deps.tryRunGit ?? tryRunGit)(args, opts.repoRoot);
+  if (result.ok) {
+    return;
+  }
+  const failure = `git ${args.join(" ")} failed: ${result.stderr || "exit 1"}`;
+  const remainingWorktrees = (deps.listWorktrees ?? listGitWorktrees)(opts.repoRoot);
+  if (isRegisteredWorktree(remainingWorktrees, opts.worktreePath)) {
+    throw new Error(failure);
+  }
+  try {
+    (deps.removeDirectory ?? removeDirectory)(opts.worktreePath);
+  } catch (error) {
+    throw new Error(`${failure}; cleanup failed: ${errorMessage(error)}`);
+  }
+}
+
+class BunGitGateway {
+  resolveWorktreeRoot(cwd) {
+    return resolveWorktreeRoot(cwd);
+  }
+  resolveWorktreeGitDir(cwd) {
+    return resolveWorktreeGitDir(cwd);
+  }
+  listWorktrees(cwd) {
+    return listGitWorktrees(cwd);
+  }
+  listLocalBranches(cwd) {
+    return listLocalGitBranches(cwd);
+  }
+  readWorktreeStatus(cwd) {
+    return readGitWorktreeStatus(cwd);
+  }
+  createWorktree(opts) {
+    const args = ["worktree", "add"];
+    if (opts.mode === "new") {
+      args.push("-b", opts.branch, opts.worktreePath);
+      if (opts.baseBranch)
+        args.push(opts.baseBranch);
+    } else {
+      args.push(opts.worktreePath, opts.branch);
+    }
+    runGit(args, opts.repoRoot);
+  }
+  removeWorktree(opts) {
+    removeGitWorktree(opts);
+  }
+  deleteBranch(repoRoot, branch, force = false) {
+    runGit(["branch", force ? "-D" : "-d", branch], repoRoot);
+  }
+  mergeBranch(opts) {
+    const current = currentCheckoutRef(opts.repoRoot);
+    const shouldRestore = current.branch !== opts.targetBranch;
+    if (shouldRestore) {
+      runGit(["checkout", opts.targetBranch], opts.repoRoot);
+    }
+    let mergeError = null;
+    const cleanupErrors = [];
+    try {
+      runGit(["merge", "--no-ff", "--no-edit", opts.sourceBranch], opts.repoRoot);
+    } catch (error) {
+      mergeError = errorMessage(error);
+      const abort = tryRunGit(["merge", "--abort"], opts.repoRoot);
+      if (!abort.ok && abort.stderr.length > 0 && !abort.stderr.includes("MERGE_HEAD missing")) {
+        cleanupErrors.push(`merge abort failed: ${abort.stderr}`);
+      }
+    }
+    if (shouldRestore) {
+      const restore = tryRunGit(["checkout", current.ref], opts.repoRoot);
+      if (!restore.ok) {
+        cleanupErrors.push(`restore checkout failed: ${restore.stderr}`);
+      }
+    }
+    if (mergeError) {
+      const suffix = cleanupErrors.length > 0 ? `; ${cleanupErrors.join("; ")}` : "";
+      throw new Error(`${mergeError}${suffix}`);
+    }
+    if (cleanupErrors.length > 0) {
+      throw new Error(cleanupErrors.join("; "));
+    }
+  }
+  currentBranch(repoRoot) {
+    return runGit(["branch", "--show-current"], repoRoot);
+  }
+}
+var init_git = () => {};
+
+// bin/src/completions.ts
+var exports_completions = {};
+__export(exports_completions, {
+  runCompletionCommand: () => runCompletionCommand,
+  listWorktreeBranches: () => listWorktreeBranches,
+  handleCompletions: () => handleCompletions,
+  extractBranches: () => extractBranches
+});
+import { basename, dirname, resolve as resolve2 } from "path";
+function extractBranches(porcelainOutput, mainWorktreePath) {
+  const entries = parseGitWorktreePorcelain(porcelainOutput);
+  const resolvedMain = mainWorktreePath ? resolve2(mainWorktreePath) : null;
+  return entries.filter((e) => !e.bare && (!resolvedMain || resolve2(e.path) !== resolvedMain)).map((e) => e.branch ?? basename(e.path));
+}
+function defaultRunGit(args) {
+  const result = Bun.spawnSync(["git", ...args], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  return {
+    exitCode: result.exitCode,
+    stdout: new TextDecoder().decode(result.stdout).trim()
+  };
+}
+function listWorktreeBranches(deps = { runGit: defaultRunGit }) {
+  const worktreeResult = deps.runGit(["worktree", "list", "--porcelain"]);
+  if (worktreeResult.exitCode !== 0)
+    return [];
+  const commonDirResult = deps.runGit(["rev-parse", "--git-common-dir"]);
+  const mainPath = commonDirResult.exitCode === 0 ? dirname(resolve2(commonDirResult.stdout)) : null;
+  return extractBranches(worktreeResult.stdout, mainPath);
+}
+function handleCompletions(args) {
+  const subcommand = args[0];
+  if (!subcommand || !BRANCH_SUBCOMMANDS.has(subcommand)) {
+    return;
+  }
+  const branches = listWorktreeBranches();
+  for (const branch of branches) {
+    console.log(branch);
+  }
+}
+function isCompletionShell(value) {
+  return value === "bash" || value === "zsh";
+}
+function runCompletionCommand(args) {
+  const shell = args[0];
+  if (!shell || shell === "--help" || shell === "-h") {
+    console.log([
+      "Usage:",
+      "  webmux completion <bash|zsh>",
+      "",
+      "Add this to your shell config to enable autocompletion:",
+      "",
+      "  # ~/.zshrc",
+      '  eval "$(webmux completion zsh)"',
+      "",
+      "  # ~/.bashrc",
+      '  eval "$(webmux completion bash)"'
+    ].join(`
+`));
+    return 0;
+  }
+  if (!isCompletionShell(shell)) {
+    console.error(`Unknown shell: ${shell}. Supported: bash, zsh`);
+    return 1;
+  }
+  console.log(generateCompletionScript(shell));
+  return 0;
+}
+function generateCompletionScript(shell) {
+  switch (shell) {
+    case "zsh":
+      return ZSH_SCRIPT;
+    case "bash":
+      return BASH_SCRIPT;
+  }
+}
+var BRANCH_SUBCOMMANDS, ZSH_SCRIPT = `#compdef webmux
+
+_webmux() {
+  local -a commands
+  commands=(
+    'serve:Start the dashboard server'
+    'init:Interactive project setup'
+    'service:Manage webmux as a system service'
+    'update:Update webmux to the latest version'
+    'add:Create a worktree'
+    'list:List worktrees and their status'
+    'open:Open an existing worktree session'
+    'close:Close a worktree session'
+    'remove:Remove a worktree'
+    'merge:Merge a worktree into main'
+    'prune:Remove all worktrees in the current project'
+    'completion:Generate shell completion script'
+  )
+
+  if (( CURRENT == 2 )); then
+    _describe 'command' commands
+    return
+  fi
+
+  case "\${words[2]}" in
+    open|close|remove|merge)
+      if (( CURRENT == 3 )); then
+        local -a branches
+        branches=(\${(f)"$(webmux --completions "\${words[2]}" 2>/dev/null)"})
+        if (( \${#branches} )); then
+          _describe 'worktree' branches
+        fi
+      fi
+      ;;
+    completion)
+      if (( CURRENT == 3 )); then
+        local -a shells
+        shells=('bash:Bash completion script' 'zsh:Zsh completion script')
+        _describe 'shell' shells
+      fi
+      ;;
+    service)
+      if (( CURRENT == 3 )); then
+        local -a actions
+        actions=(
+          'install:Install webmux as a system service'
+          'uninstall:Remove the system service'
+          'status:Show service status'
+          'logs:Show service logs'
+        )
+        _describe 'action' actions
+      fi
+      ;;
+  esac
+}
+
+compdef _webmux webmux`, BASH_SCRIPT = `_webmux() {
+  local cur prev
+  COMPREPLY=()
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+
+  if [[ \${COMP_CWORD} -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "serve init service update add list open close remove merge prune completion" -- "\${cur}"))
+    return
+  fi
+
+  case "\${COMP_WORDS[1]}" in
+    open|close|remove|merge)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        local branches
+        branches=$(webmux --completions "\${COMP_WORDS[1]}" 2>/dev/null)
+        COMPREPLY=($(compgen -W "\${branches}" -- "\${cur}"))
+      fi
+      ;;
+    completion)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "bash zsh" -- "\${cur}"))
+      fi
+      ;;
+    service)
+      if [[ \${COMP_CWORD} -eq 2 ]]; then
+        COMPREPLY=($(compgen -W "install uninstall status logs" -- "\${cur}"))
+      fi
+      ;;
+  esac
+}
+
+complete -F _webmux webmux`;
+var init_completions = __esm(() => {
+  init_git();
+  BRANCH_SUBCOMMANDS = new Set(["open", "close", "remove", "merge"]);
+});
+
 // node_modules/.bun/sisteransi@1.0.5/node_modules/sisteransi/src/index.js
 var require_src = __commonJS((exports, module) => {
   var ESC = "\x1B";
@@ -993,7 +1388,7 @@ var init_dist2 = __esm(() => {
 
 // bin/src/shared.ts
 import { existsSync, readFileSync } from "fs";
-import { basename, join } from "path";
+import { basename as basename2, join } from "path";
 function run(cmd, args, opts) {
   const result = Bun.spawnSync([cmd, ...args], { stdout: "pipe", stderr: "pipe", ...opts });
   return {
@@ -1020,12 +1415,12 @@ function detectProjectName(gitRoot) {
         return pkg.name;
     } catch {}
   }
-  return basename(gitRoot);
+  return basename2(gitRoot);
 }
 var init_shared = () => {};
 
 // bin/src/init-helpers.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
 import { tmpdir } from "os";
 import { join as join2 } from "path";
 function isRecord(value) {
@@ -1427,7 +1822,7 @@ async function runInitAgentCommand(spec, cwd, handlers = {}) {
     try {
       summary = readFileSync2(spec.summaryPath, "utf8").trim() || summary;
     } finally {
-      rmSync(spec.summaryPath, { force: true });
+      rmSync2(spec.summaryPath, { force: true });
     }
   }
   return { exitCode, stdout: stdoutResult.raw, stderr, summary };
@@ -1713,6 +2108,7 @@ ${result.stderr.trim()}` : ""
   console.log();
   console.log("  1. Review .webmux.yaml and adjust panes, ports, and profiles if needed");
   console.log("  2. Run: webmux");
+  console.log('  3. Enable tab completion: eval "$(webmux completion zsh)"  (or bash)');
   console.log();
 });
 
@@ -1772,7 +2168,7 @@ ExecStart=${config.webmuxPath} serve --port ${config.port}
 WorkingDirectory=${config.projectDir}
 Restart=on-failure
 RestartSec=5
-Environment=BACKEND_PORT=${config.port}
+Environment=PORT=${config.port}
 Environment=WEBMUX_PROJECT_DIR=${config.projectDir}
 Environment=PATH=${process.env.PATH}
 
@@ -1810,7 +2206,7 @@ function generateLaunchdPlist(config) {
   <string>${logPath}</string>
   <key>EnvironmentVariables</key>
   <dict>
-    <key>BACKEND_PORT</key>
+    <key>PORT</key>
     <string>${config.port}</string>
     <key>WEBMUX_PROJECT_DIR</key>
     <string>${config.projectDir}</string>
@@ -2009,7 +2405,7 @@ async function service(args) {
     R2.error("Could not find webmux in PATH.");
     return;
   }
-  let port = parseInt(process.env.BACKEND_PORT || "5111");
+  let port = parseInt(process.env.PORT || "5111");
   for (let i = 1;i < args.length; i++) {
     if (args[i] === "--port" && args[i + 1]) {
       const parsed = parseInt(args[++i]);
@@ -2189,7 +2585,7 @@ var init_fs = __esm(() => {
 
 // backend/src/adapters/tmux.ts
 import { createHash } from "crypto";
-import { basename as basename2, resolve } from "path";
+import { basename as basename3, resolve as resolve3 } from "path";
 function runTmux(args) {
   const result = Bun.spawnSync(["tmux", ...args], {
     stdout: "pipe",
@@ -2214,8 +2610,8 @@ function sanitizeTmuxNameSegment(value, maxLength = 24) {
   return trimmed || "x";
 }
 function buildProjectSessionName(projectRoot) {
-  const resolved = resolve(projectRoot);
-  const base = sanitizeTmuxNameSegment(basename2(resolved), 18);
+  const resolved = resolve3(projectRoot);
+  const base = sanitizeTmuxNameSegment(basename3(resolved), 18);
   const hash = createHash("sha1").update(resolved).digest("hex").slice(0, 8);
   return `wm-${base}-${hash}`;
 }
@@ -2240,9 +2636,9 @@ class BunTmuxGateway {
   }
   ensureSession(sessionName, cwd) {
     const check = runTmux(["has-session", "-t", sessionName]);
-    if (check.exitCode === 0)
-      return;
-    assertTmuxOk(["new-session", "-d", "-s", sessionName, "-c", cwd], `create tmux session ${sessionName}`);
+    if (check.exitCode !== 0) {
+      assertTmuxOk(["new-session", "-d", "-s", sessionName, "-c", cwd], `create tmux session ${sessionName}`);
+    }
   }
   hasWindow(sessionName, windowName) {
     const result = runTmux(["list-windows", "-t", sessionName, "-F", "#{window_name}"]);
@@ -9431,7 +9827,8 @@ function parseLinkedRepos(raw) {
     return [];
   return raw.filter(isRecord3).filter((entry) => typeof entry.repo === "string").map((entry) => ({
     repo: entry.repo,
-    alias: typeof entry.alias === "string" ? entry.alias : entry.repo.split("/").pop() ?? "repo"
+    alias: typeof entry.alias === "string" ? entry.alias : entry.repo.split("/").pop() ?? "repo",
+    ...typeof entry.dir === "string" && entry.dir.trim() ? { dir: entry.dir.trim() } : {}
   }));
 }
 function isDockerProfile(profile) {
@@ -9471,7 +9868,7 @@ function loadConfig(dir) {
       startupEnvs: parseStartupEnvs(parsed.startupEnvs),
       integrations: {
         github: {
-          linkedRepos: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : []
+          linkedRepos: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : isRecord3(parsed.integrations) && Array.isArray(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github) : []
         },
         linear: {
           enabled: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled
@@ -9521,7 +9918,7 @@ var init_config = __esm(() => {
 
 // backend/src/adapters/control-token.ts
 import { chmod, mkdir as mkdir2 } from "fs/promises";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 async function loadControlToken() {
   if (cachedToken)
     return cachedToken;
@@ -9531,7 +9928,7 @@ async function loadControlToken() {
     return cachedToken;
   }
   const controlToken = crypto.randomUUID();
-  await mkdir2(dirname(CONTROL_TOKEN_PATH), { recursive: true });
+  await mkdir2(dirname2(CONTROL_TOKEN_PATH), { recursive: true });
   await Bun.write(CONTROL_TOKEN_PATH, controlToken);
   await chmod(CONTROL_TOKEN_PATH, 384);
   cachedToken = controlToken;
@@ -9822,224 +10219,14 @@ var init_docker = __esm(() => {
   init_log();
 });
 
-// backend/src/adapters/git.ts
-import { rmSync as rmSync2 } from "fs";
-import { resolve as resolve2 } from "path";
-function runGit(args, cwd) {
-  const result = Bun.spawnSync(["git", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  if (result.exitCode !== 0) {
-    const stderr = new TextDecoder().decode(result.stderr).trim();
-    throw new Error(`git ${args.join(" ")} failed: ${stderr || `exit ${result.exitCode}`}`);
+// backend/src/adapters/hooks.ts
+import { join as join7 } from "path";
+function buildErrorMessage(name, exitCode, stdout, stderr) {
+  const output = stderr.trim() || stdout.trim();
+  if (output) {
+    return `${name} hook failed (exit ${exitCode}): ${output}`;
   }
-  return new TextDecoder().decode(result.stdout).trim();
-}
-function tryRunGit(args, cwd) {
-  const result = Bun.spawnSync(["git", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  if (result.exitCode !== 0) {
-    return {
-      ok: false,
-      stderr: new TextDecoder().decode(result.stderr).trim()
-    };
-  }
-  return {
-    ok: true,
-    stdout: new TextDecoder().decode(result.stdout).trim()
-  };
-}
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-function isRegisteredWorktree(entries, worktreePath) {
-  const resolvedPath = resolve2(worktreePath);
-  return entries.some((entry) => resolve2(entry.path) === resolvedPath);
-}
-function removeDirectory(path) {
-  rmSync2(path, {
-    recursive: true,
-    force: true
-  });
-}
-function currentCheckoutRef(cwd) {
-  const symbolicRef = tryRunGit(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd);
-  if (symbolicRef.ok && symbolicRef.stdout.length > 0) {
-    return {
-      ref: symbolicRef.stdout,
-      branch: symbolicRef.stdout
-    };
-  }
-  return {
-    ref: runGit(["rev-parse", "--verify", "HEAD"], cwd),
-    branch: null
-  };
-}
-function resolveWorktreeRoot(cwd) {
-  const output = runGit(["rev-parse", "--show-toplevel"], cwd);
-  return resolve2(cwd, output);
-}
-function resolveWorktreeGitDir(cwd) {
-  const output = runGit(["rev-parse", "--git-dir"], cwd);
-  return resolve2(cwd, output);
-}
-function parseGitWorktreePorcelain(output) {
-  const entries = [];
-  let current = null;
-  const flush = () => {
-    if (current?.path)
-      entries.push(current);
-    current = null;
-  };
-  for (const rawLine of output.split(`
-`)) {
-    const line = rawLine.trimEnd();
-    if (!line) {
-      flush();
-      continue;
-    }
-    if (line.startsWith("worktree ")) {
-      flush();
-      current = {
-        path: line.slice("worktree ".length),
-        branch: null,
-        head: null,
-        detached: false,
-        bare: false
-      };
-      continue;
-    }
-    if (!current)
-      continue;
-    if (line.startsWith("branch ")) {
-      current.branch = line.slice("branch ".length).replace(/^refs\/heads\//, "");
-      continue;
-    }
-    if (line.startsWith("HEAD ")) {
-      current.head = line.slice("HEAD ".length);
-      continue;
-    }
-    if (line === "detached") {
-      current.detached = true;
-      continue;
-    }
-    if (line === "bare") {
-      current.bare = true;
-    }
-  }
-  flush();
-  return entries;
-}
-function listGitWorktrees(cwd) {
-  const output = runGit(["worktree", "list", "--porcelain"], cwd);
-  return parseGitWorktreePorcelain(output);
-}
-function readGitWorktreeStatus(cwd) {
-  const dirtyOutput = runGit(["status", "--porcelain"], cwd);
-  const commit = tryRunGit(["rev-parse", "HEAD"], cwd);
-  const ahead = tryRunGit(["rev-list", "--count", "@{upstream}..HEAD"], cwd);
-  return {
-    dirty: dirtyOutput.length > 0,
-    aheadCount: ahead.ok ? parseInt(ahead.stdout, 10) || 0 : 0,
-    currentCommit: commit.ok && commit.stdout.length > 0 ? commit.stdout : null
-  };
-}
-function removeGitWorktree(opts, deps2 = {}) {
-  const args = ["worktree", "remove"];
-  if (opts.force)
-    args.push("--force");
-  args.push(opts.worktreePath);
-  const result = (deps2.tryRunGit ?? tryRunGit)(args, opts.repoRoot);
-  if (result.ok) {
-    return;
-  }
-  const failure = `git ${args.join(" ")} failed: ${result.stderr || "exit 1"}`;
-  const remainingWorktrees = (deps2.listWorktrees ?? listGitWorktrees)(opts.repoRoot);
-  if (isRegisteredWorktree(remainingWorktrees, opts.worktreePath)) {
-    throw new Error(failure);
-  }
-  try {
-    (deps2.removeDirectory ?? removeDirectory)(opts.worktreePath);
-  } catch (error) {
-    throw new Error(`${failure}; cleanup failed: ${errorMessage(error)}`);
-  }
-}
-
-class BunGitGateway {
-  resolveWorktreeRoot(cwd) {
-    return resolveWorktreeRoot(cwd);
-  }
-  resolveWorktreeGitDir(cwd) {
-    return resolveWorktreeGitDir(cwd);
-  }
-  listWorktrees(cwd) {
-    return listGitWorktrees(cwd);
-  }
-  readWorktreeStatus(cwd) {
-    return readGitWorktreeStatus(cwd);
-  }
-  createWorktree(opts) {
-    const args = ["worktree", "add", "-b", opts.branch, opts.worktreePath];
-    if (opts.baseBranch)
-      args.push(opts.baseBranch);
-    runGit(args, opts.repoRoot);
-  }
-  removeWorktree(opts) {
-    removeGitWorktree(opts);
-  }
-  deleteBranch(repoRoot, branch, force = false) {
-    runGit(["branch", force ? "-D" : "-d", branch], repoRoot);
-  }
-  mergeBranch(opts) {
-    const current = currentCheckoutRef(opts.repoRoot);
-    const shouldRestore = current.branch !== opts.targetBranch;
-    if (shouldRestore) {
-      runGit(["checkout", opts.targetBranch], opts.repoRoot);
-    }
-    let mergeError = null;
-    const cleanupErrors = [];
-    try {
-      runGit(["merge", "--no-ff", "--no-edit", opts.sourceBranch], opts.repoRoot);
-    } catch (error) {
-      mergeError = errorMessage(error);
-      const abort = tryRunGit(["merge", "--abort"], opts.repoRoot);
-      if (!abort.ok && abort.stderr.length > 0 && !abort.stderr.includes("MERGE_HEAD missing")) {
-        cleanupErrors.push(`merge abort failed: ${abort.stderr}`);
-      }
-    }
-    if (shouldRestore) {
-      const restore = tryRunGit(["checkout", current.ref], opts.repoRoot);
-      if (!restore.ok) {
-        cleanupErrors.push(`restore checkout failed: ${restore.stderr}`);
-      }
-    }
-    if (mergeError) {
-      const suffix = cleanupErrors.length > 0 ? `; ${cleanupErrors.join("; ")}` : "";
-      throw new Error(`${mergeError}${suffix}`);
-    }
-    if (cleanupErrors.length > 0) {
-      throw new Error(cleanupErrors.join("; "));
-    }
-  }
-  currentBranch(repoRoot) {
-    return runGit(["branch", "--show-current"], repoRoot);
-  }
-}
-var init_git = () => {};
-
-// backend/src/adapters/hooks.ts
-import { join as join7 } from "path";
-function buildErrorMessage(name, exitCode, stdout, stderr) {
-  const output = stderr.trim() || stdout.trim();
-  if (output) {
-    return `${name} hook failed (exit ${exitCode}): ${output}`;
-  }
-  return `${name} hook failed (exit ${exitCode})`;
+  return `${name} hook failed (exit ${exitCode})`;
 }
 function hasDirenv() {
   try {
@@ -10103,7 +10290,7 @@ class BunPortProbe {
     this.hostnames = hostnames;
   }
   isListening(port) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       let settled = false;
       let pending = this.hostnames.length;
       const settle = (result) => {
@@ -10112,20 +10299,20 @@ class BunPortProbe {
         if (result) {
           settled = true;
           clearTimeout(timer);
-          resolve3(true);
+          resolve4(true);
           return;
         }
         pending--;
         if (pending === 0) {
           settled = true;
           clearTimeout(timer);
-          resolve3(false);
+          resolve4(false);
         }
       };
       const timer = setTimeout(() => {
         if (!settled) {
           settled = true;
-          resolve3(false);
+          resolve4(false);
         }
       }, this.timeoutMs);
       for (const hostname of this.hostnames) {
@@ -10149,10 +10336,6 @@ class BunPortProbe {
 }
 
 // backend/src/services/auto-name-service.ts
-function buildPrompt(task) {
-  return `Task description:
-${task.trim()}`;
-}
 function normalizeGeneratedBranchName(raw) {
   let branch = raw.trim();
   branch = branch.replace(/^```[\w-]*\s*/, "").replace(/\s*```$/, "");
@@ -10164,6 +10347,7 @@ function normalizeGeneratedBranchName(raw) {
   branch = branch.replace(/[/.]+/g, "-");
   branch = branch.replace(/-+/g, "-");
   branch = branch.replace(/^-+|-+$/g, "");
+  branch = branch.slice(0, MAX_BRANCH_LENGTH).replace(/-+$/, "");
   if (!branch) {
     throw new Error("Auto-name model returned an empty branch name");
   }
@@ -10206,6 +10390,9 @@ function buildClaudeArgs(model, systemPrompt, prompt) {
 function escapeTomlString(s) {
   return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
 }
+function buildPrompt(prompt) {
+  return `Here is the task description: ${prompt}. You MUST return the branch name only, no other text or comments. Be fast, make it simple, and concise.`;
+}
 function buildCodexArgs(model, systemPrompt, prompt) {
   const args = [
     "codex",
@@ -10252,20 +10439,21 @@ class AutoNameService {
     return normalizeGeneratedBranchName(output);
   }
 }
-var DEFAULT_SYSTEM_PROMPT;
+var MAX_BRANCH_LENGTH = 40, DEFAULT_SYSTEM_PROMPT;
 var init_auto_name_service = __esm(() => {
   init_policies();
   DEFAULT_SYSTEM_PROMPT = [
     "Generate a concise git branch name from the task description.",
     "Return only the branch name.",
     "Use lowercase kebab-case.",
+    `Maximum ${MAX_BRANCH_LENGTH} characters.`,
     "Do not include quotes, code fences, or prefixes like feature/ or fix/."
   ].join(" ");
 });
 
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname2, join as join8 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -10532,7 +10720,7 @@ async function ensureAgentRuntimeArtifacts(input) {
     agentCtlPath: join8(storagePaths.webmuxDir, "webmux-agentctl"),
     claudeSettingsPath: join8(input.worktreePath, ".claude", "settings.local.json")
   };
-  await mkdir3(dirname2(artifacts.claudeSettingsPath), { recursive: true });
+  await mkdir3(dirname3(artifacts.claudeSettingsPath), { recursive: true });
   await Bun.write(artifacts.agentCtlPath, buildAgentCtlScript());
   await chmod2(artifacts.agentCtlPath, 493);
   const hookSettings = buildClaudeHookSettings(artifacts);
@@ -10555,15 +10743,22 @@ function buildRuntimeBootstrap(runtimeEnvPath) {
   return `set -a; . ${quoteShell(runtimeEnvPath)}; set +a`;
 }
 function buildAgentInvocation(input) {
-  const promptSuffix = input.prompt ? ` ${quoteShell(input.prompt)}` : "";
   if (input.agent === "codex") {
     const yoloFlag2 = input.yolo ? " --yolo" : "";
+    if (input.launchMode === "resume") {
+      return `codex${yoloFlag2} resume --last`;
+    }
+    const promptSuffix2 = input.prompt ? ` ${quoteShell(input.prompt)}` : "";
     if (input.systemPrompt) {
-      return `codex${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix}`;
+      return `codex${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix2}`;
     }
-    return `codex${yoloFlag2}${promptSuffix}`;
+    return `codex${yoloFlag2}${promptSuffix2}`;
   }
   const yoloFlag = input.yolo ? " --dangerously-skip-permissions" : "";
+  if (input.launchMode === "resume") {
+    return `claude${yoloFlag} --continue`;
+  }
+  const promptSuffix = input.prompt ? ` ${quoteShell(input.prompt)}` : "";
   if (input.systemPrompt) {
     return `claude${yoloFlag} --append-system-prompt ${quoteShell(input.systemPrompt)}${promptSuffix}`;
   }
@@ -10646,6 +10841,7 @@ function ensureSessionLayout(tmux, plan) {
     cwd: rootPane.cwd,
     command: plan.shellCommand
   });
+  tmux.setWindowOption(plan.sessionName, plan.windowName, "pane-base-index", "0");
   tmux.setWindowOption(plan.sessionName, plan.windowName, "automatic-rename", "off");
   tmux.setWindowOption(plan.sessionName, plan.windowName, "allow-rename", "off");
   for (const pane of plan.panes.slice(1)) {
@@ -10704,10 +10900,12 @@ function rollbackManagedWorktreeCreation(opts, sessionLayoutPlan, git, deps2) {
   } catch (error) {
     cleanupErrors.push(`worktree rollback failed: ${toErrorMessage(error)}`);
   }
-  try {
-    git.deleteBranch(opts.repoRoot, opts.branch, true);
-  } catch (error) {
-    cleanupErrors.push(`branch rollback failed: ${toErrorMessage(error)}`);
+  if (opts.deleteBranchOnRollback ?? true) {
+    try {
+      git.deleteBranch(opts.repoRoot, opts.branch, true);
+    } catch (error) {
+      cleanupErrors.push(`branch rollback failed: ${toErrorMessage(error)}`);
+    }
   }
   return cleanupErrors.length > 0 ? joinErrorMessages(cleanupErrors) : null;
 }
@@ -10757,6 +10955,7 @@ async function createManagedWorktree(opts, deps2 = {}) {
       repoRoot: opts.repoRoot,
       worktreePath: opts.worktreePath,
       branch: opts.branch,
+      mode: opts.mode,
       baseBranch: opts.baseBranch
     });
     worktreeCreated = true;
@@ -10819,7 +11018,7 @@ var init_worktree_service = __esm(() => {
 // backend/src/services/lifecycle-service.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname3, resolve as resolve3 } from "path";
+import { dirname as dirname4, resolve as resolve4 } from "path";
 function generateBranchName() {
   return `change-${randomUUID2().slice(0, 8)}`;
 }
@@ -10836,19 +11035,29 @@ class LifecycleService {
     this.deps = deps2;
   }
   async createWorktree(input) {
-    const branch = await this.resolveBranch(input.branch, input.prompt);
-    this.ensureBranchAvailable(branch);
+    const mode = input.mode ?? "new";
+    const branch = await this.resolveBranch(input.branch, input.prompt, mode);
+    this.ensureBranchAvailable(branch, mode);
     const { profileName, profile } = this.resolveProfile(input.profile);
     const agent = this.resolveAgent(input.agent);
     const worktreePath = this.resolveWorktreePath(branch);
+    const deleteBranchOnRollback = mode === "new";
     let initialized = null;
     try {
-      await mkdir4(dirname3(worktreePath), { recursive: true });
+      await this.reportCreateProgress({
+        branch,
+        path: worktreePath,
+        profile: profileName,
+        agent,
+        phase: "creating_worktree"
+      });
+      await mkdir4(dirname4(worktreePath), { recursive: true });
       initialized = await createManagedWorktree({
         repoRoot: this.deps.projectRoot,
         worktreePath,
         branch,
-        baseBranch: this.deps.config.workspace.mainBranch,
+        mode,
+        ...mode === "new" ? { baseBranch: this.deps.config.workspace.mainBranch } : {},
         profile: profileName,
         agent,
         runtime: profile.runtime,
@@ -10856,13 +11065,17 @@ class LifecycleService {
         allocatedPorts: await this.allocatePorts(),
         runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: worktreePath },
         controlUrl: this.controlUrl(),
-        controlToken: await this.deps.getControlToken()
+        controlToken: await this.deps.getControlToken(),
+        deleteBranchOnRollback
       }, {
         git: this.deps.git
       });
-      await ensureAgentRuntimeArtifacts({
-        gitDir: initialized.paths.gitDir,
-        worktreePath
+      await this.reportCreateProgress({
+        branch,
+        path: worktreePath,
+        profile: profileName,
+        agent,
+        phase: "running_post_create_hook"
       });
       await this.runLifecycleHook({
         name: "postCreate",
@@ -10870,13 +11083,44 @@ class LifecycleService {
         meta: initialized.meta,
         worktreePath
       });
+      initialized = await this.refreshManagedArtifactsFromMeta({
+        gitDir: initialized.paths.gitDir,
+        meta: initialized.meta,
+        worktreePath
+      });
+      await this.reportCreateProgress({
+        branch,
+        path: worktreePath,
+        profile: profileName,
+        agent,
+        phase: "preparing_runtime"
+      });
+      await ensureAgentRuntimeArtifacts({
+        gitDir: initialized.paths.gitDir,
+        worktreePath
+      });
+      await this.reportCreateProgress({
+        branch,
+        path: worktreePath,
+        profile: profileName,
+        agent,
+        phase: "starting_session"
+      });
       await this.materializeRuntimeSession({
         branch,
         profile,
         agent,
         initialized,
         worktreePath,
-        prompt: input.prompt
+        prompt: input.prompt,
+        launchMode: "fresh"
+      });
+      await this.reportCreateProgress({
+        branch,
+        path: worktreePath,
+        profile: profileName,
+        agent,
+        phase: "reconciling"
       });
       await this.deps.reconciliation.reconcile(this.deps.projectRoot);
       return {
@@ -10885,17 +11129,20 @@ class LifecycleService {
       };
     } catch (error) {
       if (initialized) {
-        const cleanupError = await this.cleanupFailedCreate(branch, worktreePath, profile.runtime);
+        const cleanupError = await this.cleanupFailedCreate(branch, worktreePath, profile.runtime, deleteBranchOnRollback);
         if (cleanupError) {
           throw this.wrapOperationError(new Error(`${toErrorMessage2(error)}; ${cleanupError}`));
         }
       }
       throw this.wrapOperationError(error);
+    } finally {
+      await this.finishCreateProgress(branch);
     }
   }
   async openWorktree(branch) {
     try {
       const resolved = await this.resolveExistingWorktree(branch);
+      const launchMode = resolved.meta ? "resume" : "fresh";
       const initialized = resolved.meta ? await this.refreshManagedArtifacts(resolved) : await this.initializeUnmanagedWorktree(resolved);
       const { profile } = this.resolveProfile(initialized.meta.profile);
       await ensureAgentRuntimeArtifacts({
@@ -10907,7 +11154,8 @@ class LifecycleService {
         profile,
         agent: initialized.meta.agent,
         initialized,
-        worktreePath: resolved.entry.path
+        worktreePath: resolved.entry.path,
+        launchMode
       });
       await this.deps.reconciliation.reconcile(this.deps.projectRoot);
       return {
@@ -10935,6 +11183,20 @@ class LifecycleService {
       throw this.wrapOperationError(error);
     }
   }
+  async pruneWorktrees() {
+    try {
+      const resolvedWorktrees = await this.resolveAllWorktrees();
+      const removedBranches = [];
+      for (const resolved of resolvedWorktrees) {
+        const branch = resolved.entry.branch ?? resolved.entry.path;
+        await this.removeResolvedWorktree(resolved);
+        removedBranches.push(branch);
+      }
+      return { removedBranches };
+    } catch (error) {
+      throw this.wrapOperationError(error);
+    }
+  }
   async mergeWorktree(branch) {
     try {
       const resolved = await this.resolveExistingWorktree(branch);
@@ -10953,9 +11215,17 @@ class LifecycleService {
       throw this.wrapOperationError(error);
     }
   }
-  async resolveBranch(rawBranch, prompt) {
+  listAvailableBranches() {
+    const localBranches = this.listLocalBranches().filter((branch) => isValidBranchName(branch));
+    const checkedOutBranches = this.listCheckedOutBranches();
+    return localBranches.filter((branch) => !checkedOutBranches.has(branch)).sort((left, right) => left.localeCompare(right)).map((name) => ({ name }));
+  }
+  async resolveBranch(rawBranch, prompt, mode) {
     const explicitBranch = rawBranch?.trim();
-    const branch = explicitBranch || await this.generateAutoName(prompt) || generateBranchName();
+    const branch = mode === "existing" ? explicitBranch : explicitBranch || await this.generateAutoName(prompt) || generateBranchName();
+    if (!branch) {
+      throw new LifecycleError("Existing branch is required", 400);
+    }
     if (!isValidBranchName(branch)) {
       throw new LifecycleError(`Invalid branch name: ${branch}`, 400);
     }
@@ -10967,10 +11237,19 @@ class LifecycleService {
     }
     return await this.deps.autoName.generateBranchName(this.deps.config.autoName, prompt);
   }
-  ensureBranchAvailable(branch) {
-    const exists = this.listProjectWorktrees().some((entry) => entry.branch === branch);
-    if (exists) {
-      throw new LifecycleError(`Worktree already exists: ${branch}`, 409);
+  ensureBranchAvailable(branch, mode) {
+    const localBranches = new Set(this.listLocalBranches());
+    if (mode === "new") {
+      if (localBranches.has(branch)) {
+        throw new LifecycleError(`Branch already exists: ${branch}`, 409);
+      }
+      return;
+    }
+    if (!localBranches.has(branch)) {
+      throw new LifecycleError(`Branch not found: ${branch}`, 404);
+    }
+    if (this.listCheckedOutBranches().has(branch)) {
+      throw new LifecycleError(`Branch already has a worktree: ${branch}`, 409);
     }
   }
   resolveProfile(profileName) {
@@ -11007,11 +11286,17 @@ class LifecycleService {
     return allocateServicePorts(metas, this.deps.config.services);
   }
   resolveWorktreePath(branch) {
-    return resolve3(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
+    return resolve4(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
+  }
+  listLocalBranches() {
+    return this.deps.git.listLocalBranches(resolve4(this.deps.projectRoot));
+  }
+  listCheckedOutBranches() {
+    return new Set(this.deps.git.listWorktrees(resolve4(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
   }
   listProjectWorktrees() {
-    const projectRoot = resolve3(this.deps.projectRoot);
-    return this.deps.git.listWorktrees(projectRoot).filter((entry) => !entry.bare && resolve3(entry.path) !== projectRoot);
+    const projectRoot = resolve4(this.deps.projectRoot);
+    return this.deps.git.listWorktrees(projectRoot).filter((entry) => !entry.bare && resolve4(entry.path) !== projectRoot);
   }
   async readManagedMetas() {
     const metas = await Promise.all(this.listProjectWorktrees().map(async (entry) => {
@@ -11029,6 +11314,14 @@ class LifecycleService {
     const meta = await readWorktreeMeta(gitDir);
     return { entry, gitDir, meta };
   }
+  async resolveAllWorktrees() {
+    const entries = this.listProjectWorktrees().sort((left, right) => (left.branch ?? left.path).localeCompare(right.branch ?? right.path));
+    return await Promise.all(entries.map(async (entry) => {
+      const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
+      const meta = await readWorktreeMeta(gitDir);
+      return { entry, gitDir, meta };
+    }));
+  }
   async initializeUnmanagedWorktree(resolved) {
     const { profileName, profile } = this.resolveProfile(undefined);
     const dotenvValues = await loadDotenvLocal(resolved.entry.path);
@@ -11050,21 +11343,28 @@ class LifecycleService {
     if (!resolved.meta) {
       throw new Error("Missing managed metadata");
     }
-    const dotenvValues = await loadDotenvLocal(resolved.entry.path);
-    const runtimeEnv = buildRuntimeEnvMap(resolved.meta, {
-      WEBMUX_WORKTREE_PATH: resolved.entry.path
+    return await this.refreshManagedArtifactsFromMeta({
+      gitDir: resolved.gitDir,
+      meta: resolved.meta,
+      worktreePath: resolved.entry.path
+    });
+  }
+  async refreshManagedArtifactsFromMeta(input) {
+    const dotenvValues = await loadDotenvLocal(input.worktreePath);
+    const runtimeEnv = buildRuntimeEnvMap(input.meta, {
+      WEBMUX_WORKTREE_PATH: input.worktreePath
     }, dotenvValues);
-    await writeRuntimeEnv(resolved.gitDir, runtimeEnv);
+    await writeRuntimeEnv(input.gitDir, runtimeEnv);
     const controlEnv = buildControlEnvMap({
       controlUrl: this.controlUrl(),
       controlToken: await this.deps.getControlToken(),
-      worktreeId: resolved.meta.worktreeId,
-      branch: resolved.meta.branch
+      worktreeId: input.meta.worktreeId,
+      branch: input.meta.branch
     });
-    await writeControlEnv(resolved.gitDir, controlEnv);
+    await writeControlEnv(input.gitDir, controlEnv);
     return {
-      meta: resolved.meta,
-      paths: getWorktreeStoragePaths(resolved.gitDir),
+      meta: input.meta,
+      paths: getWorktreeStoragePaths(input.gitDir),
       runtimeEnv,
       controlEnv
     };
@@ -11087,6 +11387,7 @@ class LifecycleService {
         initialized: input.initialized,
         worktreePath: input.worktreePath,
         prompt: input.prompt,
+        launchMode: input.launchMode,
         containerName: containerName2
       }));
       return;
@@ -11097,11 +11398,12 @@ class LifecycleService {
       agent: input.agent,
       initialized: input.initialized,
       worktreePath: input.worktreePath,
-      prompt: input.prompt
+      prompt: input.prompt,
+      launchMode: input.launchMode
     }));
   }
   buildSessionLayout(input) {
-    const systemPrompt = input.profile.systemPrompt ? expandTemplate(input.profile.systemPrompt, input.initialized.runtimeEnv) : undefined;
+    const systemPrompt = input.launchMode === "fresh" && input.profile.systemPrompt ? expandTemplate(input.profile.systemPrompt, input.initialized.runtimeEnv) : undefined;
     const containerName2 = input.containerName;
     return planSessionLayout(this.deps.projectRoot, input.branch, input.profile.panes, {
       repoRoot: this.deps.projectRoot,
@@ -11114,7 +11416,8 @@ class LifecycleService {
           runtimeEnvPath: input.initialized.paths.runtimeEnvPath,
           yolo: input.profile.yolo === true,
           systemPrompt,
-          prompt: input.prompt
+          prompt: input.launchMode === "fresh" ? input.prompt : undefined,
+          launchMode: input.launchMode
         }),
         shell: buildDockerShellCommand(containerName2, input.worktreePath, input.initialized.paths.runtimeEnvPath)
       } : {
@@ -11123,7 +11426,8 @@ class LifecycleService {
           runtimeEnvPath: input.initialized.paths.runtimeEnvPath,
           yolo: input.profile.yolo === true,
           systemPrompt,
-          prompt: input.prompt
+          prompt: input.launchMode === "fresh" ? input.prompt : undefined,
+          launchMode: input.launchMode
         }),
         shell: buildManagedShellCommand(input.initialized.paths.runtimeEnvPath)
       }
@@ -11135,7 +11439,7 @@ class LifecycleService {
     }
     return profile;
   }
-  async cleanupFailedCreate(branch, worktreePath, runtime) {
+  async cleanupFailedCreate(branch, worktreePath, runtime, deleteBranch) {
     const cleanupErrors = [];
     if (runtime === "docker") {
       try {
@@ -11155,8 +11459,8 @@ class LifecycleService {
         worktreePath,
         branch,
         force: true,
-        deleteBranch: true,
-        deleteBranchForce: true
+        deleteBranch,
+        deleteBranchForce: deleteBranch
       }, this.deps.git);
     } catch (error) {
       cleanupErrors.push(`worktree cleanup failed: ${toErrorMessage2(error)}`);
@@ -11212,6 +11516,12 @@ class LifecycleService {
     });
     console.debug(`[lifecycle-hook] COMPLETED ${input.name}`);
   }
+  async reportCreateProgress(progress) {
+    await this.deps.onCreateProgress?.(progress);
+  }
+  async finishCreateProgress(branch) {
+    await this.deps.onCreateFinished?.(branch);
+  }
   wrapOperationError(error) {
     if (error instanceof LifecycleError) {
       return error;
@@ -11509,9 +11819,9 @@ var init_project_runtime = __esm(() => {
 });
 
 // backend/src/services/reconciliation-service.ts
-import { basename as basename3, resolve as resolve4 } from "path";
+import { basename as basename4, resolve as resolve5 } from "path";
 function makeUnmanagedWorktreeId(path) {
-  return `unmanaged:${resolve4(path)}`;
+  return `unmanaged:${resolve5(path)}`;
 }
 function isValidPort2(port) {
   return port !== null && Number.isInteger(port) && port >= 1 && port <= 65535;
@@ -11544,7 +11854,7 @@ function findWindow(windows, sessionName, branch) {
   return windows.find((window) => window.sessionName === sessionName && window.windowName === windowName) ?? null;
 }
 function resolveBranch(entry, metaBranch) {
-  const fallback = basename3(entry.path);
+  const fallback = basename4(entry.path);
   return entry.branch ?? metaBranch ?? (fallback.length > 0 ? fallback : "unknown");
 }
 
@@ -11554,7 +11864,7 @@ class ReconciliationService {
     this.deps = deps2;
   }
   async reconcile(repoRoot) {
-    const normalizedRepoRoot = resolve4(repoRoot);
+    const normalizedRepoRoot = resolve5(repoRoot);
     const worktrees = this.deps.git.listWorktrees(normalizedRepoRoot);
     const sessionName = buildProjectSessionName(normalizedRepoRoot);
     let windows = [];
@@ -11567,7 +11877,7 @@ class ReconciliationService {
     for (const entry of worktrees) {
       if (entry.bare)
         continue;
-      if (resolve4(entry.path) === normalizedRepoRoot)
+      if (resolve5(entry.path) === normalizedRepoRoot)
         continue;
       const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
       const meta = await readWorktreeMeta(gitDir);
@@ -11624,9 +11934,33 @@ var init_reconciliation_service = __esm(() => {
   init_fs();
 });
 
+// backend/src/services/worktree-creation-service.ts
+class WorktreeCreationTracker {
+  worktrees = new Map;
+  set(progress) {
+    const next = {
+      branch: progress.branch,
+      path: progress.path,
+      profile: progress.profile,
+      agentName: progress.agent,
+      phase: progress.phase
+    };
+    this.worktrees.set(progress.branch, next);
+  }
+  clear(branch) {
+    return this.worktrees.delete(branch);
+  }
+  has(branch) {
+    return this.worktrees.has(branch);
+  }
+  list() {
+    return [...this.worktrees.values()].sort((left, right) => left.branch.localeCompare(right.branch)).map((state) => ({ ...state }));
+  }
+}
+
 // backend/src/runtime.ts
 function createWebmuxRuntime(options = {}) {
-  const port = options.port ?? parseInt(Bun.env.BACKEND_PORT || "5111", 10);
+  const port = options.port ?? parseInt(Bun.env.PORT || "5111", 10);
   const projectDir = gitRoot2(options.projectDir ?? Bun.env.WEBMUX_PROJECT_DIR ?? process.cwd());
   const config = loadConfig(projectDir);
   const git = new BunGitGateway;
@@ -11636,6 +11970,7 @@ function createWebmuxRuntime(options = {}) {
   const hooks = new BunLifecycleHookRunner;
   const autoName = new AutoNameService;
   const projectRuntime = new ProjectRuntime;
+  const worktreeCreationTracker = new WorktreeCreationTracker;
   const runtimeNotifications = new NotificationService;
   const reconciliationService = new ReconciliationService({
     config,
@@ -11654,7 +11989,13 @@ function createWebmuxRuntime(options = {}) {
     docker,
     reconciliation: reconciliationService,
     hooks,
-    autoName
+    autoName,
+    onCreateProgress: (progress) => {
+      worktreeCreationTracker.set(progress);
+    },
+    onCreateFinished: (branch) => {
+      worktreeCreationTracker.clear(branch);
+    }
   });
   return {
     port,
@@ -11667,6 +12008,7 @@ function createWebmuxRuntime(options = {}) {
     hooks,
     autoName,
     projectRuntime,
+    worktreeCreationTracker,
     runtimeNotifications,
     reconciliationService,
     lifecycleService
@@ -11693,7 +12035,7 @@ __export(exports_worktree_commands, {
   parseAddCommandArgs: () => parseAddCommandArgs,
   getWorktreeCommandUsage: () => getWorktreeCommandUsage
 });
-import { basename as basename4, resolve as resolve5 } from "path";
+import { basename as basename5, resolve as resolve6 } from "path";
 function getWorktreeCommandUsage(command) {
   switch (command) {
     case "add":
@@ -11724,6 +12066,9 @@ function getWorktreeCommandUsage(command) {
     case "merge":
       return `Usage:
   webmux merge <branch>`;
+    case "prune":
+      return `Usage:
+  webmux prune`;
   }
 }
 function readOptionValue(args, index, flag) {
@@ -11826,8 +12171,31 @@ function parseBranchCommandArgs(args) {
   }
   return branch;
 }
+function parsePruneCommandArgs(args) {
+  for (const arg of args) {
+    if (arg === "--help" || arg === "-h") {
+      return false;
+    }
+    if (arg.startsWith("-")) {
+      throw new CommandUsageError(`Unknown option: ${arg}`);
+    }
+    throw new CommandUsageError(`Unexpected argument: ${arg}`);
+  }
+  return true;
+}
+function listProjectWorktrees(runtime) {
+  const projectDir = resolve6(runtime.projectDir);
+  return runtime.git.listWorktrees(projectDir).filter((entry) => !entry.bare && resolve6(entry.path) !== projectDir);
+}
+async function defaultConfirmPrune(worktreeCount) {
+  const response = await Rt({
+    message: `Prune all ${worktreeCount} worktree${worktreeCount === 1 ? "" : "s"}? This action cannot be undone.`,
+    initialValue: false
+  });
+  return !Ct(response) && response;
+}
 function defaultSwitchToTmuxWindow(projectDir, branch) {
-  const sessionName = buildProjectSessionName(resolve5(projectDir));
+  const sessionName = buildProjectSessionName(resolve6(projectDir));
   const windowName = buildWorktreeWindowName(branch);
   const target = `${sessionName}:${windowName}`;
   const selectResult = Bun.spawnSync(["tmux", "select-window", "-t", target], {
@@ -11856,8 +12224,8 @@ function defaultSwitchToTmuxWindow(projectDir, branch) {
   }
 }
 async function listWorktrees(runtime, stdout) {
-  const projectDir = resolve5(runtime.projectDir);
-  const entries = runtime.git.listWorktrees(projectDir).filter((entry) => !entry.bare && resolve5(entry.path) !== projectDir);
+  const projectDir = resolve6(runtime.projectDir);
+  const entries = listProjectWorktrees(runtime);
   if (entries.length === 0) {
     stdout("No worktrees found.");
     return;
@@ -11871,7 +12239,7 @@ async function listWorktrees(runtime, stdout) {
   }
   const openWindows = new Set(windows.filter((w) => w.sessionName === sessionName).map((w) => w.windowName));
   const rows = await Promise.all(entries.map(async (entry) => {
-    const branch = entry.branch ?? basename4(entry.path);
+    const branch = entry.branch ?? basename5(entry.path);
     const isOpen = openWindows.has(buildWorktreeWindowName(branch));
     const gitDir = runtime.git.resolveWorktreeGitDir(entry.path);
     const meta = await readWorktreeMeta(gitDir);
@@ -11890,6 +12258,7 @@ async function runWorktreeCommand(context, deps2 = {}) {
   const stdout = deps2.stdout ?? ((message) => console.log(message));
   const stderr = deps2.stderr ?? ((message) => console.error(message));
   const switchToTmuxWindow = deps2.switchToTmuxWindow ?? defaultSwitchToTmuxWindow;
+  const confirmPrune = deps2.confirmPrune ?? defaultConfirmPrune;
   try {
     if (context.command === "add") {
       const input = parseAddCommandArgs(context.args);
@@ -11918,6 +12287,32 @@ async function runWorktreeCommand(context, deps2 = {}) {
       await listWorktrees(runtime2, stdout);
       return 0;
     }
+    if (context.command === "prune") {
+      if (!parsePruneCommandArgs(context.args)) {
+        stdout(getWorktreeCommandUsage("prune"));
+        return 0;
+      }
+      const runtime2 = createRuntime({
+        projectDir: context.projectDir,
+        port: context.port
+      });
+      const worktrees = listProjectWorktrees(runtime2);
+      if (worktrees.length === 0) {
+        stdout("No worktrees found.");
+        return 0;
+      }
+      if (!await confirmPrune(worktrees.length)) {
+        stdout("Aborted.");
+        return 0;
+      }
+      const result = await runtime2.lifecycleService.pruneWorktrees();
+      if (result.removedBranches.length === 0) {
+        stdout("No worktrees found.");
+        return 0;
+      }
+      stdout(`Pruned ${result.removedBranches.length} worktree${result.removedBranches.length === 1 ? "" : "s"}: ${result.removedBranches.join(", ")}`);
+      return 0;
+    }
     const command = context.command;
     const branch = parseBranchCommandArgs(context.args);
     if (!branch) {
@@ -11953,6 +12348,7 @@ async function runWorktreeCommand(context, deps2 = {}) {
 }
 var CommandUsageError;
 var init_worktree_commands = __esm(() => {
+  init_dist2();
   init_fs();
   init_tmux();
   init_policies();
@@ -11962,10 +12358,67 @@ var init_worktree_commands = __esm(() => {
 });
 
 // bin/src/webmux.ts
-import { resolve as resolve6, dirname as dirname4, join as join10 } from "path";
+import { resolve as resolve7, dirname as dirname5, join as join10 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import { fileURLToPath } from "url";
-var PKG_ROOT = resolve6(dirname4(fileURLToPath(import.meta.url)), "..");
+// package.json
+var package_default = {
+  name: "webmux",
+  version: "0.13.0",
+  description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
+  type: "module",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/windmill-labs/workmux-web.git"
+  },
+  homepage: "https://github.com/windmill-labs/workmux-web",
+  keywords: [
+    "workmux",
+    "git-worktree",
+    "tmux",
+    "dashboard",
+    "terminal",
+    "ai-agent"
+  ],
+  bin: {
+    webmux: "bin/webmux.js"
+  },
+  workspaces: [
+    "backend",
+    "frontend"
+  ],
+  scripts: {
+    dev: "bash dev.sh",
+    start: "bun bin/webmux.js",
+    build: "cd frontend && bun run build && cd .. && bun build backend/src/server.ts --target=bun --outfile=backend/dist/server.js && bun build bin/src/webmux.ts --target=bun --outfile=bin/webmux.js",
+    prepublishOnly: "bun run build",
+    test: "bun run --cwd backend test && bun test bin/src && bun run --cwd frontend test",
+    "test:coverage": "bun run --cwd backend test --coverage && bun test --coverage bin/src && bun run --cwd frontend test:coverage"
+  },
+  files: [
+    "bin/webmux.js",
+    "backend/dist/",
+    "frontend/dist/"
+  ],
+  devDependencies: {
+    "@clack/prompts": "^1.1.0",
+    "@sveltejs/vite-plugin-svelte": "^5.0.0",
+    "@tailwindcss/vite": "^4.2.0",
+    "@types/bun": "latest",
+    "@xterm/addon-fit": "^0.10.0",
+    "@xterm/addon-web-links": "^0.11.0",
+    "@xterm/xterm": "^5.5.0",
+    svelte: "^5.0.0",
+    "svelte-check": "^4.0.0",
+    tailwindcss: "^4.2.0",
+    typescript: "^5.0.0",
+    vite: "^6.0.0"
+  },
+  license: "MIT"
+};
+
+// bin/src/webmux.ts
+var PKG_ROOT = resolve7(dirname5(fileURLToPath(import.meta.url)), "..");
 function usage2() {
   console.log(`
 webmux \u2014 Dev dashboard for managing Git worktrees
@@ -11981,21 +12434,27 @@ Usage:
   webmux close        Close a worktree session without removing it
   webmux remove       Remove a worktree
   webmux merge        Merge a worktree into the main branch and remove it
+  webmux prune        Remove all worktrees in the current project
+  webmux completion   Generate shell completion script (bash, zsh)
 
 Options:
   --port N            Set port (default: 5111)
   --debug             Show debug-level logs
+  --version           Show version number
   --help              Show this help message
 
 Environment:
-  BACKEND_PORT     Same as --port (flag takes precedence)
+  PORT             Same as --port (flag takes precedence)
 `);
 }
 function isRootCommand(value) {
-  return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "list" || value === "open" || value === "close" || value === "remove" || value === "merge";
+  return value === "serve" || value === "init" || value === "service" || value === "update" || value === "add" || value === "list" || value === "open" || value === "close" || value === "remove" || value === "merge" || value === "prune" || value === "completion";
+}
+function isServeRootOption(value) {
+  return value === "--port" || value === "--debug" || value === "--help" || value === "-h" || value === "--version" || value === "-V";
 }
 function parseRootArgs(args) {
-  let port = parseInt(process.env.BACKEND_PORT || "5111", 10);
+  let port = parseInt(process.env.PORT || "5111", 10);
   let debug = false;
   let command = null;
   const commandArgs = [];
@@ -12003,7 +12462,7 @@ function parseRootArgs(args) {
     const arg = args[index];
     if (!arg)
       continue;
-    if (command) {
+    if (command && (command !== "serve" || !isServeRootOption(arg))) {
       commandArgs.push(arg);
       continue;
     }
@@ -12023,6 +12482,11 @@ function parseRootArgs(args) {
       case "--debug":
         debug = true;
         break;
+      case "--version":
+      case "-V":
+        console.log(package_default.version);
+        process.exit(0);
+        break;
       case "--help":
       case "-h":
         usage2();
@@ -12043,34 +12507,7 @@ Run webmux --help for usage.`);
   };
 }
 function isWorktreeCommand(command) {
-  return command === "add" || command === "list" || command === "open" || command === "close" || command === "remove" || command === "merge";
-}
-var args = process.argv.slice(2);
-var parsed;
-try {
-  parsed = parseRootArgs(args);
-} catch (error) {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-}
-if (parsed.command === "init") {
-  await init_init().then(() => exports_init);
-  process.exit(0);
-}
-if (parsed.command === "service") {
-  const { default: service2 } = await Promise.resolve().then(() => (init_service(), exports_service));
-  await service2(parsed.commandArgs);
-  process.exit(0);
-}
-if (parsed.command === "update") {
-  console.log("Updating webmux to the latest version...");
-  const proc = Bun.spawn(["bun", "install", "--global", "webmux@latest"], {
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit"
-  });
-  const code = await proc.exited;
-  process.exit(code);
+  return command === "add" || command === "list" || command === "open" || command === "close" || command === "remove" || command === "merge" || command === "prune";
 }
 async function loadEnvFile(path) {
   if (!existsSync5(path))
@@ -12091,32 +12528,6 @@ async function loadEnvFile(path) {
     }
   }
 }
-await loadEnvFile(resolve6(process.cwd(), ".env.local"));
-await loadEnvFile(resolve6(process.cwd(), ".env"));
-if (isWorktreeCommand(parsed.command)) {
-  const { runWorktreeCommand: runWorktreeCommand2 } = await Promise.resolve().then(() => (init_worktree_commands(), exports_worktree_commands));
-  const exitCode = await runWorktreeCommand2({
-    command: parsed.command,
-    args: parsed.commandArgs,
-    projectDir: process.cwd(),
-    port: parsed.port
-  });
-  process.exit(exitCode);
-}
-if (parsed.command === null) {
-  usage2();
-  process.exit(0);
-}
-if (!existsSync5(resolve6(process.cwd(), ".webmux.yaml"))) {
-  console.error("No .webmux.yaml found in this directory.\nRun `webmux init` to set up your project.");
-  process.exit(1);
-}
-var baseEnv = {
-  ...process.env,
-  BACKEND_PORT: String(parsed.port),
-  WEBMUX_PROJECT_DIR: process.cwd(),
-  ...parsed.debug ? { WEBMUX_DEBUG: "1" } : {}
-};
 function pipeWithPrefix(stream, prefix) {
   const reader = stream.getReader();
   const decoder = new TextDecoder;
@@ -12139,41 +12550,110 @@ function pipeWithPrefix(stream, prefix) {
     }
   })();
 }
-var children = [];
-var exiting = false;
-function cleanup() {
-  if (exiting)
+async function main(args = process.argv.slice(2)) {
+  if (args[0] === "--completions") {
+    const { handleCompletions: handleCompletions2 } = await Promise.resolve().then(() => (init_completions(), exports_completions));
+    handleCompletions2(args.slice(1));
     return;
-  exiting = true;
-  for (const child of children) {
-    try {
-      child.kill("SIGTERM");
-    } catch {}
   }
-  setTimeout(() => {
+  let parsed;
+  try {
+    parsed = parseRootArgs(args);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  if (parsed.command === "completion") {
+    const { runCompletionCommand: runCompletionCommand2 } = await Promise.resolve().then(() => (init_completions(), exports_completions));
+    process.exit(runCompletionCommand2(parsed.commandArgs));
+  }
+  if (parsed.command === "init") {
+    await init_init().then(() => exports_init);
+    process.exit(0);
+  }
+  if (parsed.command === "service") {
+    const { default: service2 } = await Promise.resolve().then(() => (init_service(), exports_service));
+    await service2(parsed.commandArgs);
+    process.exit(0);
+  }
+  if (parsed.command === "update") {
+    console.log("Updating webmux to the latest version...");
+    const proc = Bun.spawn(["bun", "install", "--global", "webmux@latest"], {
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+    const code = await proc.exited;
+    process.exit(code);
+  }
+  await loadEnvFile(resolve7(process.cwd(), ".env.local"));
+  await loadEnvFile(resolve7(process.cwd(), ".env"));
+  if (isWorktreeCommand(parsed.command)) {
+    const { runWorktreeCommand: runWorktreeCommand2 } = await Promise.resolve().then(() => (init_worktree_commands(), exports_worktree_commands));
+    const exitCode = await runWorktreeCommand2({
+      command: parsed.command,
+      args: parsed.commandArgs,
+      projectDir: process.cwd(),
+      port: parsed.port
+    });
+    process.exit(exitCode);
+  }
+  if (parsed.command === null) {
+    usage2();
+    process.exit(0);
+  }
+  if (!existsSync5(resolve7(process.cwd(), ".webmux.yaml"))) {
+    console.error("No .webmux.yaml found in this directory.\nRun `webmux init` to set up your project.");
+    process.exit(1);
+  }
+  const baseEnv = {
+    ...process.env,
+    PORT: String(parsed.port),
+    WEBMUX_PROJECT_DIR: process.cwd(),
+    ...parsed.debug ? { WEBMUX_DEBUG: "1" } : {}
+  };
+  const children = [];
+  let exiting = false;
+  function cleanup() {
+    if (exiting)
+      return;
+    exiting = true;
     for (const child of children) {
       try {
-        child.kill("SIGKILL");
+        child.kill("SIGTERM");
       } catch {}
     }
-    process.exit(0);
-  }, 1000).unref();
-}
-process.on("SIGINT", cleanup);
-process.on("SIGTERM", cleanup);
-var backendEntry = join10(PKG_ROOT, "backend", "dist", "server.js");
-var staticDir = join10(PKG_ROOT, "frontend", "dist");
-if (!existsSync5(staticDir)) {
-  console.error(`Error: frontend/dist/ not found. Run 'bun run build' first.`);
-  process.exit(1);
-}
-console.log(`Starting webmux on port ${parsed.port}...`);
-var be = Bun.spawn(["bun", backendEntry], {
-  env: { ...baseEnv, WEBMUX_STATIC_DIR: staticDir },
-  stdout: "pipe",
-  stderr: "pipe"
-});
-children.push(be);
-pipeWithPrefix(be.stdout, "[BE]");
-pipeWithPrefix(be.stderr, "[BE]");
-await be.exited;
+    setTimeout(() => {
+      for (const child of children) {
+        try {
+          child.kill("SIGKILL");
+        } catch {}
+      }
+      process.exit(0);
+    }, 1000).unref();
+  }
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  const backendEntry = join10(PKG_ROOT, "backend", "dist", "server.js");
+  const staticDir = join10(PKG_ROOT, "frontend", "dist");
+  if (!existsSync5(staticDir)) {
+    console.error(`Error: frontend/dist/ not found. Run 'bun run build' first.`);
+    process.exit(1);
+  }
+  console.log(`Starting webmux on port ${parsed.port}...`);
+  const be = Bun.spawn(["bun", backendEntry], {
+    env: { ...baseEnv, WEBMUX_STATIC_DIR: staticDir },
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  children.push(be);
+  pipeWithPrefix(be.stdout, "[BE]");
+  pipeWithPrefix(be.stderr, "[BE]");
+  await be.exited;
+}
+if (import.meta.main) {
+  await main();
+}
+export {
+  parseRootArgs
+};