webmux 0.11.0 → 0.13.0

package/backend/dist/server.js

@@ -6932,7 +6932,7 @@ var log = {
 // backend/src/adapters/terminal.ts
 var textDecoder = new TextDecoder;
 var textEncoder = new TextEncoder;
-var DASH_PORT = Bun.env.BACKEND_PORT || "5111";
+var DASH_PORT = Bun.env.PORT || "5111";
 var SESSION_PREFIX = `wm-dash-${DASH_PORT}-`;
 var MAX_SCROLLBACK_BYTES = 1 * 1024 * 1024;
 var TMUX_TIMEOUT_MS = 5000;
@@ -7413,7 +7413,8 @@ function parseLinkedRepos(raw) {
     return [];
   return raw.filter(isRecord).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) {
@@ -7453,7 +7454,7 @@ function loadConfig(dir) {
       startupEnvs: parseStartupEnvs(parsed.startupEnvs),
       integrations: {
         github: {
-          linkedRepos: isRecord(parsed.integrations) && isRecord(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : []
+          linkedRepos: isRecord(parsed.integrations) && isRecord(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : isRecord(parsed.integrations) && Array.isArray(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github) : []
         },
         linear: {
           enabled: isRecord(parsed.integrations) && isRecord(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled
@@ -8088,9 +8089,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}"]);
@@ -8188,15 +8189,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}`;
   }
@@ -8279,6 +8287,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)) {
@@ -8419,6 +8428,11 @@ 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);
@@ -8460,13 +8474,21 @@ class BunGitGateway {
   listWorktrees(cwd) {
     return listGitWorktrees(cwd);
   }
+  listLocalBranches(cwd) {
+    return listLocalGitBranches(cwd);
+  }
   readWorktreeStatus(cwd) {
     return readGitWorktreeStatus(cwd);
   }
   createWorktree(opts) {
-    const args = ["worktree", "add", "-b", opts.branch, opts.worktreePath];
-    if (opts.baseBranch)
-      args.push(opts.baseBranch);
+    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) {
@@ -8545,10 +8567,12 @@ function rollbackManagedWorktreeCreation(opts, sessionLayoutPlan, git, deps) {
   } 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;
 }
@@ -8598,6 +8622,7 @@ async function createManagedWorktree(opts, deps = {}) {
       repoRoot: opts.repoRoot,
       worktreePath: opts.worktreePath,
       branch: opts.branch,
+      mode: opts.mode,
       baseBranch: opts.baseBranch
     });
     worktreeCreated = true;
@@ -8677,19 +8702,29 @@ class LifecycleService {
     this.deps = deps;
   }
   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 this.reportCreateProgress({
+        branch,
+        path: worktreePath,
+        profile: profileName,
+        agent,
+        phase: "creating_worktree"
+      });
       await mkdir4(dirname3(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,
@@ -8697,13 +8732,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",
@@ -8711,13 +8750,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 {
@@ -8726,17 +8796,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({
@@ -8748,7 +8821,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 {
@@ -8776,6 +8850,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);
@@ -8794,9 +8882,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);
     }
@@ -8808,10 +8904,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) {
@@ -8850,6 +8955,12 @@ class LifecycleService {
   resolveWorktreePath(branch) {
     return resolve3(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
   }
+  listLocalBranches() {
+    return this.deps.git.listLocalBranches(resolve3(this.deps.projectRoot));
+  }
+  listCheckedOutBranches() {
+    return new Set(this.deps.git.listWorktrees(resolve3(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);
@@ -8870,6 +8981,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);
@@ -8891,21 +9010,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
     };
@@ -8928,6 +9054,7 @@ class LifecycleService {
         initialized: input.initialized,
         worktreePath: input.worktreePath,
         prompt: input.prompt,
+        launchMode: input.launchMode,
         containerName
       }));
       return;
@@ -8938,11 +9065,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 containerName = input.containerName;
     return planSessionLayout(this.deps.projectRoot, input.branch, input.profile.panes, {
       repoRoot: this.deps.projectRoot,
@@ -8955,7 +9083,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(containerName, input.worktreePath, input.initialized.paths.runtimeEnvPath)
       } : {
@@ -8964,7 +9093,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)
       }
@@ -8976,7 +9106,7 @@ class LifecycleService {
     }
     return profile;
   }
-  async cleanupFailedCreate(branch, worktreePath, runtime) {
+  async cleanupFailedCreate(branch, worktreePath, runtime, deleteBranch) {
     const cleanupErrors = [];
     if (runtime === "docker") {
       try {
@@ -8996,8 +9126,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)}`);
@@ -9053,6 +9183,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;
@@ -9420,7 +9556,12 @@ function clonePrEntry(pr) {
     comments: pr.comments.map((comment) => ({ ...comment }))
   };
 }
-function mapWorktreeSnapshot(state, now, findLinearIssue) {
+function mapCreationSnapshot(creating) {
+  return creating ? {
+    phase: creating.phase
+  } : null;
+}
+function mapWorktreeSnapshot(state, now, creating, findLinearIssue) {
   return {
     branch: state.branch,
     path: state.path,
@@ -9430,21 +9571,51 @@ function mapWorktreeSnapshot(state, now, findLinearIssue) {
     mux: state.session.exists,
     dirty: state.git.dirty || state.git.aheadCount > 0,
     paneCount: state.session.paneCount,
-    status: state.agent.lifecycle,
+    status: creating ? "creating" : state.agent.lifecycle,
     elapsed: formatElapsedSince(state.agent.lastStartedAt, now),
     services: state.services.map((service) => ({ ...service })),
     prs: state.prs.map((pr) => clonePrEntry(pr)),
-    linearIssue: findLinearIssue ? findLinearIssue(state.branch) : null
+    linearIssue: findLinearIssue ? findLinearIssue(state.branch) : null,
+    creation: mapCreationSnapshot(creating)
+  };
+}
+function mapCreatingWorktreeSnapshot(creating, findLinearIssue) {
+  return {
+    branch: creating.branch,
+    path: creating.path,
+    dir: creating.path,
+    profile: creating.profile,
+    agentName: creating.agentName,
+    mux: false,
+    dirty: false,
+    paneCount: 0,
+    status: "creating",
+    elapsed: "",
+    services: [],
+    prs: [],
+    linearIssue: findLinearIssue ? findLinearIssue(creating.branch) : null,
+    creation: mapCreationSnapshot(creating)
   };
 }
 function buildProjectSnapshot(input) {
   const now = input.now ?? (() => new Date);
+  const creatingWorktrees = input.creatingWorktrees ?? [];
+  const creatingByBranch = new Map(creatingWorktrees.map((worktree) => [worktree.branch, worktree]));
+  const runtimeWorktrees = input.runtime.listWorktrees();
+  const runtimeBranches = new Set(runtimeWorktrees.map((worktree) => worktree.branch));
+  const worktrees = runtimeWorktrees.map((state) => mapWorktreeSnapshot(state, now, creatingByBranch.get(state.branch) ?? null, input.findLinearIssue));
+  for (const creating of creatingWorktrees) {
+    if (!runtimeBranches.has(creating.branch)) {
+      worktrees.push(mapCreatingWorktreeSnapshot(creating, input.findLinearIssue));
+    }
+  }
+  worktrees.sort((left, right) => left.branch.localeCompare(right.branch));
   return {
     project: {
       name: input.projectName,
       mainBranch: input.mainBranch
     },
-    worktrees: input.runtime.listWorktrees().map((state) => mapWorktreeSnapshot(state, now, input.findLinearIssue)),
+    worktrees,
     notifications: input.notifications.map((notification) => ({ ...notification }))
   };
 }
@@ -9859,16 +10030,14 @@ class BunPortProbe {
 }
 
 // backend/src/services/auto-name-service.ts
+var MAX_BRANCH_LENGTH = 40;
 var 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(" ");
-function buildPrompt(task) {
-  return `Task description:
-${task.trim()}`;
-}
 function normalizeGeneratedBranchName(raw) {
   let branch = raw.trim();
   branch = branch.replace(/^```[\w-]*\s*/, "").replace(/\s*```$/, "");
@@ -9880,6 +10049,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");
   }
@@ -9922,6 +10092,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",
@@ -10348,9 +10521,33 @@ class ReconciliationService {
   }
 }
 
+// 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 = gitRoot(options.projectDir ?? Bun.env.WEBMUX_PROJECT_DIR ?? process.cwd());
   const config = loadConfig(projectDir);
   const git = new BunGitGateway;
@@ -10360,6 +10557,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,
@@ -10378,7 +10576,13 @@ function createWebmuxRuntime(options = {}) {
     docker,
     reconciliation: reconciliationService,
     hooks,
-    autoName
+    autoName,
+    onCreateProgress: (progress) => {
+      worktreeCreationTracker.set(progress);
+    },
+    onCreateFinished: (branch) => {
+      worktreeCreationTracker.clear(branch);
+    }
   });
   return {
     port,
@@ -10391,6 +10595,7 @@ function createWebmuxRuntime(options = {}) {
     hooks,
     autoName,
     projectRuntime,
+    worktreeCreationTracker,
     runtimeNotifications,
     reconciliationService,
     lifecycleService
@@ -10398,7 +10603,7 @@ function createWebmuxRuntime(options = {}) {
 }
 
 // backend/src/server.ts
-var PORT = parseInt(Bun.env.BACKEND_PORT || "5111", 10);
+var PORT = parseInt(Bun.env.PORT || "5111", 10);
 var STATIC_DIR = Bun.env.WEBMUX_STATIC_DIR || "";
 var runtime = createWebmuxRuntime({
   port: PORT,
@@ -10409,6 +10614,7 @@ var config = runtime.config;
 var git = runtime.git;
 var tmux = runtime.tmux;
 var projectRuntime = runtime.projectRuntime;
+var worktreeCreationTracker = runtime.worktreeCreationTracker;
 var runtimeNotifications = runtime.runtimeNotifications;
 var reconciliationService = runtime.reconciliationService;
 var removingBranches = new Set;
@@ -10431,7 +10637,11 @@ function getFrontendConfig() {
     })),
     defaultProfileName,
     autoName: config.autoName !== null,
-    startupEnvs: config.startupEnvs
+    startupEnvs: config.startupEnvs,
+    linkedRepos: config.integrations.github.linkedRepos.map((lr) => ({
+      alias: lr.alias,
+      ...lr.dir ? { dir: resolve5(PROJECT_DIR, lr.dir) } : {}
+    }))
   };
 }
 function parseWsMessage(raw) {
@@ -10489,8 +10699,17 @@ function ensureBranchNotRemoving(branch) {
     throw new LifecycleError(`Worktree is being removed: ${branch}`, 409);
   }
 }
-async function withRemovingBranch(branch, fn) {
+function ensureBranchNotCreating(branch) {
+  if (worktreeCreationTracker.has(branch)) {
+    throw new LifecycleError(`Worktree is being created: ${branch}`, 409);
+  }
+}
+function ensureBranchNotBusy(branch) {
   ensureBranchNotRemoving(branch);
+  ensureBranchNotCreating(branch);
+}
+async function withRemovingBranch(branch, fn) {
+  ensureBranchNotBusy(branch);
   removingBranches.add(branch);
   try {
     return await fn();
@@ -10499,7 +10718,7 @@ async function withRemovingBranch(branch, fn) {
   }
 }
 async function resolveTerminalWorktree(branch) {
-  ensureBranchNotRemoving(branch);
+  ensureBranchNotBusy(branch);
   await reconciliationService.reconcile(PROJECT_DIR);
   const state = projectRuntime.getWorktreeByBranch(branch);
   if (!state) {
@@ -10562,6 +10781,7 @@ async function apiGetProject() {
     projectName: config.name,
     mainBranch: config.workspace.mainBranch,
     runtime: projectRuntime,
+    creatingWorktrees: worktreeCreationTracker.list(),
     notifications: runtimeNotifications.list(),
     findLinearIssue: (branch) => {
       const match = linearIssues.find((issue) => branchMatchesIssue(branch, issue.branchName));
@@ -10602,6 +10822,11 @@ async function apiRuntimeEvent(req) {
     ...notification ? { notification } : {}
   });
 }
+async function apiListBranches() {
+  return jsonResponse({
+    branches: lifecycleService.listAvailableBranches()
+  });
+}
 async function apiCreateWorktree(req) {
   const raw = await req.json();
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
@@ -10623,8 +10848,16 @@ async function apiCreateWorktree(req) {
   const prompt = typeof body.prompt === "string" ? body.prompt : undefined;
   const profile = typeof body.profile === "string" ? body.profile : undefined;
   const agent = body.agent === "claude" || body.agent === "codex" ? body.agent : undefined;
-  log.info(`[worktree:add]${branch ? ` branch=${branch}` : ""}${profile ? ` profile=${profile}` : ""}${agent ? ` agent=${agent}` : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
+  const mode = body.mode;
+  if (mode !== undefined && mode !== "new" && mode !== "existing") {
+    return errorResponse("Invalid worktree create mode", 400);
+  }
+  if (branch) {
+    ensureBranchNotCreating(branch);
+  }
+  log.info(`[worktree:add] mode=${mode ?? "new"}${branch ? ` branch=${branch}` : ""}${profile ? ` profile=${profile}` : ""}${agent ? ` agent=${agent}` : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
   const result = await lifecycleService.createWorktree({
+    mode,
     branch,
     prompt,
     profile,
@@ -10643,19 +10876,21 @@ async function apiDeleteWorktree(name) {
   });
 }
 async function apiOpenWorktree(name) {
-  ensureBranchNotRemoving(name);
+  ensureBranchNotBusy(name);
   log.info(`[worktree:open] name=${name}`);
   const result = await lifecycleService.openWorktree(name);
   log.debug(`[worktree:open] done name=${name} worktreeId=${result.worktreeId}`);
   return jsonResponse({ ok: true });
 }
 async function apiCloseWorktree(name) {
+  ensureBranchNotBusy(name);
   log.info(`[worktree:close] name=${name}`);
   await lifecycleService.closeWorktree(name);
   log.debug(`[worktree:close] done name=${name}`);
   return jsonResponse({ ok: true });
 }
 async function apiSendPrompt(name, req) {
+  ensureBranchNotBusy(name);
   const raw = await req.json();
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
     return errorResponse("Invalid request body", 400);
@@ -10673,6 +10908,7 @@ async function apiSendPrompt(name, req) {
   return jsonResponse({ ok: true });
 }
 async function apiMergeWorktree(name) {
+  ensureBranchNotBusy(name);
   log.info(`[worktree:merge] name=${name}`);
   await lifecycleService.mergeWorktree(name);
   log.debug(`[worktree:merge] done name=${name}`);
@@ -10710,6 +10946,9 @@ Bun.serve({
     "/api/config": {
       GET: () => jsonResponse(getFrontendConfig())
     },
+    "/api/branches": {
+      GET: () => catching("GET /api/branches", () => apiListBranches())
+    },
     "/api/project": {
       GET: () => catching("GET /api/project", () => apiGetProject())
     },