webmux 0.10.1 → 0.12.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;
@@ -7399,10 +7399,12 @@ function parseLifecycleHooks(raw) {
 function parseAutoName(raw) {
   if (!isRecord(raw))
     return null;
-  if (typeof raw.model !== "string" || !raw.model.trim())
+  const provider = raw.provider;
+  if (provider !== "claude" && provider !== "codex")
     return null;
   return {
-    model: raw.model.trim(),
+    provider,
+    ...typeof raw.model === "string" && raw.model.trim() ? { model: raw.model.trim() } : {},
     ...typeof raw.system_prompt === "string" && raw.system_prompt.trim() ? { systemPrompt: raw.system_prompt.trim() } : {}
   };
 }
@@ -7411,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) {
@@ -7451,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
@@ -8086,9 +8089,10 @@ 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}`);
+    }
+    assertTmuxOk(["set-option", "-t", sessionName, "pane-base-index", "0"], `set pane-base-index on ${sessionName}`);
   }
   hasWindow(sessionName, windowName) {
     const result = runTmux(["list-windows", "-t", sessionName, "-F", "#{window_name}"]);
@@ -8682,6 +8686,13 @@ class LifecycleService {
     const worktreePath = this.resolveWorktreePath(branch);
     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,
@@ -8699,9 +8710,12 @@ class LifecycleService {
       }, {
         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",
@@ -8709,6 +8723,29 @@ 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,
@@ -8717,6 +8754,13 @@ class LifecycleService {
         worktreePath,
         prompt: input.prompt
       });
+      await this.reportCreateProgress({
+        branch,
+        path: worktreePath,
+        profile: profileName,
+        agent,
+        phase: "reconciling"
+      });
       await this.deps.reconciliation.reconcile(this.deps.projectRoot);
       return {
         branch,
@@ -8730,6 +8774,8 @@ class LifecycleService {
         }
       }
       throw this.wrapOperationError(error);
+    } finally {
+      await this.finishCreateProgress(branch);
     }
   }
   async openWorktree(branch) {
@@ -8889,21 +8935,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
     };
@@ -9051,6 +9104,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;
@@ -9418,7 +9477,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,
@@ -9428,21 +9492,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 }))
   };
 }
@@ -9857,47 +9951,14 @@ class BunPortProbe {
 }
 
 // backend/src/services/auto-name-service.ts
-var BRANCH_NAME_SCHEMA = {
-  type: "object",
-  properties: {
-    branch_name: {
-      type: "string",
-      description: "A lowercase kebab-case git branch name with no prefix"
-    }
-  },
-  required: ["branch_name"],
-  additionalProperties: false
-};
-var GEMINI_BRANCH_NAME_SCHEMA = {
-  ...BRANCH_NAME_SCHEMA,
-  propertyOrdering: ["branch_name"]
-};
+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 isRecord4(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function buildPrompt(task) {
-  return `Task description:
-${task.trim()}`;
-}
-function parseBranchNamePayload(raw) {
-  if (!isRecord4(raw) || typeof raw.branch_name !== "string") {
-    throw new Error("Auto-name response did not include branch_name");
-  }
-  return raw.branch_name;
-}
-function parseJsonText(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    throw new Error(`Auto-name response was not valid JSON: ${text}`);
-  }
-}
 function normalizeGeneratedBranchName(raw) {
   let branch = raw.trim();
   branch = branch.replace(/^```[\w-]*\s*/, "").replace(/\s*```$/, "");
@@ -9909,6 +9970,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");
   }
@@ -9917,231 +9979,87 @@ function normalizeGeneratedBranchName(raw) {
   }
   return branch;
 }
-function resolveAutoNameModel(modelSpec) {
-  const trimmed = modelSpec.trim();
-  const slashIndex = trimmed.indexOf("/");
-  if (slashIndex > 0) {
-    const provider = trimmed.slice(0, slashIndex);
-    const model = trimmed.slice(slashIndex + 1).trim().replace(/^models\//, "");
-    if (!model) {
-      throw new Error(`Invalid auto_name model: ${modelSpec}`);
-    }
-    if (provider === "anthropic" || provider === "google" || provider === "openai") {
-      return { provider, model };
-    }
-    if (provider === "gemini") {
-      return { provider: "google", model };
-    }
-  }
-  if (trimmed.startsWith("claude-")) {
-    return { provider: "anthropic", model: trimmed };
-  }
-  if (trimmed.startsWith("gemini-") || trimmed.startsWith("models/gemini-")) {
-    return { provider: "google", model: trimmed.replace(/^models\//, "") };
-  }
-  if (/^(gpt-|chatgpt-|o\d)/.test(trimmed)) {
-    return { provider: "openai", model: trimmed };
-  }
-  throw new Error(`Unsupported auto_name model provider for ${modelSpec}. Use an anthropic/, gemini/, google/, or openai/ prefix, or a known model name.`);
-}
 function getSystemPrompt(config) {
   return config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
 }
-function extractAnthropicText(raw) {
-  if (!isRecord4(raw) || !Array.isArray(raw.content))
-    return null;
-  for (const item of raw.content) {
-    if (!isRecord4(item))
-      continue;
-    if (item.type === "text" && typeof item.text === "string" && item.text.trim()) {
-      return item.text;
-    }
-  }
-  return null;
+async function defaultSpawn(args) {
+  const proc = Bun.spawn(args, {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  return { exitCode, stdout, stderr };
 }
-function extractGoogleText(raw) {
-  if (!isRecord4(raw) || !Array.isArray(raw.candidates))
-    return null;
-  for (const candidate of raw.candidates) {
-    if (!isRecord4(candidate) || !isRecord4(candidate.content) || !Array.isArray(candidate.content.parts))
-      continue;
-    for (const part of candidate.content.parts) {
-      if (isRecord4(part) && typeof part.text === "string" && part.text.trim()) {
-        return part.text;
-      }
-    }
+function buildClaudeArgs(model, systemPrompt, prompt) {
+  const args = [
+    "claude",
+    "-p",
+    "--system-prompt",
+    systemPrompt,
+    "--output-format",
+    "text",
+    "--no-session-persistence"
+  ];
+  if (model) {
+    args.push("--model", model);
   }
-  return null;
+  args.push(prompt);
+  return args;
 }
-function extractOpenAiText(raw) {
-  if (!isRecord4(raw))
-    return null;
-  if (typeof raw.output_text === "string" && raw.output_text.trim()) {
-    return raw.output_text;
-  }
-  if (!Array.isArray(raw.output))
-    return null;
-  for (const item of raw.output) {
-    if (!isRecord4(item) || !Array.isArray(item.content))
-      continue;
-    for (const content of item.content) {
-      if (!isRecord4(content))
-        continue;
-      if (typeof content.text === "string" && content.text.trim()) {
-        return content.text;
-      }
-    }
-  }
-  return null;
+function escapeTomlString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
 }
-async function readErrorBody(response) {
-  const text = (await response.text()).trim();
-  return text || `HTTP ${response.status}`;
+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",
+    "-c",
+    `developer_instructions="${escapeTomlString(systemPrompt)}"`,
+    "exec",
+    "--ephemeral"
+  ];
+  if (model) {
+    args.push("-m", model);
+  }
+  args.push(prompt);
+  return args;
 }
 
 class AutoNameService {
-  fetchImpl;
-  anthropicApiKey;
-  geminiApiKey;
-  openaiApiKey;
+  spawnImpl;
   constructor(deps = {}) {
-    this.fetchImpl = deps.fetchImpl ?? fetch;
-    this.anthropicApiKey = deps.anthropicApiKey ?? Bun.env.ANTHROPIC_API_KEY;
-    this.geminiApiKey = deps.geminiApiKey ?? Bun.env.GEMINI_API_KEY;
-    this.openaiApiKey = deps.openaiApiKey ?? Bun.env.OPENAI_API_KEY;
+    this.spawnImpl = deps.spawnImpl ?? defaultSpawn;
   }
   async generateBranchName(config, task) {
     const prompt = task.trim();
     if (!prompt) {
       throw new Error("Auto-name requires a prompt");
     }
-    const resolved = resolveAutoNameModel(config.model);
-    const branchName = resolved.provider === "anthropic" ? await this.generateWithAnthropic(resolved.model, getSystemPrompt(config), prompt) : resolved.provider === "google" ? await this.generateWithGoogle(resolved.model, getSystemPrompt(config), prompt) : await this.generateWithOpenAI(resolved.model, getSystemPrompt(config), prompt);
-    return normalizeGeneratedBranchName(branchName);
-  }
-  async generateWithAnthropic(model, systemPrompt, task) {
-    if (!this.anthropicApiKey) {
-      throw new Error("ANTHROPIC_API_KEY is required for auto_name with Anthropic models");
-    }
-    const response = await this.fetchImpl("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-api-key": this.anthropicApiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model,
-        system: systemPrompt,
-        max_tokens: 64,
-        messages: [{ role: "user", content: buildPrompt(task) }],
-        output_config: {
-          format: {
-            type: "json_schema",
-            schema: BRANCH_NAME_SCHEMA
-          }
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Anthropic auto-name request failed: ${await readErrorBody(response)}`);
-    }
-    const json = await response.json();
-    if (isRecord4(json) && json.stop_reason === "refusal") {
-      throw new Error("Anthropic auto-name request was refused");
-    }
-    if (isRecord4(json) && json.stop_reason === "max_tokens") {
-      throw new Error("Anthropic auto-name response hit max_tokens before completing");
-    }
-    const text = extractAnthropicText(json);
-    if (!text) {
-      throw new Error("Anthropic auto-name response did not include text");
-    }
-    return parseBranchNamePayload(parseJsonText(text));
-  }
-  async generateWithGoogle(model, systemPrompt, task) {
-    if (!this.geminiApiKey) {
-      throw new Error("GEMINI_API_KEY is required for auto_name with Gemini models");
-    }
-    const response = await this.fetchImpl(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:generateContent`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-goog-api-key": this.geminiApiKey
-      },
-      body: JSON.stringify({
-        systemInstruction: {
-          parts: [{ text: systemPrompt }]
-        },
-        contents: [
-          {
-            role: "user",
-            parts: [{ text: buildPrompt(task) }]
-          }
-        ],
-        generationConfig: {
-          responseMimeType: "application/json",
-          responseJsonSchema: GEMINI_BRANCH_NAME_SCHEMA
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Google auto-name request failed: ${await readErrorBody(response)}`);
-    }
-    const json = await response.json();
-    const text = extractGoogleText(json);
-    if (!text) {
-      throw new Error("Google auto-name response did not include text");
-    }
-    return parseBranchNamePayload(parseJsonText(text));
-  }
-  async generateWithOpenAI(model, systemPrompt, task) {
-    if (!this.openaiApiKey) {
-      throw new Error("OPENAI_API_KEY is required for auto_name with OpenAI models");
-    }
-    const response = await this.fetchImpl("https://api.openai.com/v1/responses", {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${this.openaiApiKey}`
-      },
-      body: JSON.stringify({
-        model,
-        input: [
-          { role: "system", content: systemPrompt },
-          { role: "user", content: buildPrompt(task) }
-        ],
-        max_output_tokens: 64,
-        text: {
-          format: {
-            type: "json_schema",
-            name: "branch_name_response",
-            strict: true,
-            schema: BRANCH_NAME_SCHEMA
-          }
-        }
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`OpenAI auto-name request failed: ${await readErrorBody(response)}`);
+    const systemPrompt = getSystemPrompt(config);
+    const userPrompt = buildPrompt(prompt);
+    const args = config.provider === "claude" ? buildClaudeArgs(config.model, systemPrompt, userPrompt) : buildCodexArgs(config.model, systemPrompt, userPrompt);
+    const cli = config.provider === "claude" ? "claude" : "codex";
+    let result;
+    try {
+      result = await this.spawnImpl(args);
+    } catch {
+      throw new Error(`'${cli}' CLI not found. Install it or check your PATH.`);
     }
-    const json = await response.json();
-    if (isRecord4(json) && Array.isArray(json.output)) {
-      for (const item of json.output) {
-        if (!isRecord4(item) || !Array.isArray(item.content))
-          continue;
-        for (const content of item.content) {
-          if (isRecord4(content) && content.type === "refusal" && typeof content.refusal === "string") {
-            throw new Error(`OpenAI auto-name request was refused: ${content.refusal}`);
-          }
-        }
-      }
+    if (result.exitCode !== 0) {
+      const detail = result.stderr.trim() || `exit ${result.exitCode}`;
+      throw new Error(`${cli} failed: ${detail}`);
     }
-    const text = extractOpenAiText(json);
-    if (!text) {
-      throw new Error("OpenAI auto-name response did not include text");
+    const output = result.stdout.trim();
+    if (!output) {
+      throw new Error(`${cli} returned empty output`);
     }
-    return parseBranchNamePayload(parseJsonText(text));
+    return normalizeGeneratedBranchName(output);
   }
 }
 
@@ -10524,9 +10442,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;
@@ -10536,6 +10478,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,
@@ -10554,7 +10497,13 @@ function createWebmuxRuntime(options = {}) {
     docker,
     reconciliation: reconciliationService,
     hooks,
-    autoName
+    autoName,
+    onCreateProgress: (progress) => {
+      worktreeCreationTracker.set(progress);
+    },
+    onCreateFinished: (branch) => {
+      worktreeCreationTracker.clear(branch);
+    }
   });
   return {
     port,
@@ -10567,6 +10516,7 @@ function createWebmuxRuntime(options = {}) {
     hooks,
     autoName,
     projectRuntime,
+    worktreeCreationTracker,
     runtimeNotifications,
     reconciliationService,
     lifecycleService
@@ -10574,7 +10524,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,
@@ -10585,6 +10535,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;
@@ -10607,7 +10558,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) {
@@ -10665,8 +10620,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();
@@ -10675,7 +10639,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) {
@@ -10738,6 +10702,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));
@@ -10799,6 +10764,9 @@ 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;
+  if (branch) {
+    ensureBranchNotCreating(branch);
+  }
   log.info(`[worktree:add]${branch ? ` branch=${branch}` : ""}${profile ? ` profile=${profile}` : ""}${agent ? ` agent=${agent}` : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
   const result = await lifecycleService.createWorktree({
     branch,
@@ -10819,19 +10787,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);
@@ -10849,6 +10819,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}`);