webmux 0.26.0 → 0.27.1

package/backend/dist/server.js

@@ -6919,7 +6919,7 @@ var require_public_api = __commonJS((exports) => {
 
 // backend/src/server.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join7, resolve as resolve7 } from "path";
+import { join as join7, resolve as resolve8 } from "path";
 import { mkdirSync } from "fs";
 import { networkInterfaces } from "os";
 
@@ -7713,6 +7713,43 @@ function hasRecentDashboardActivity() {
   return Date.now() - lastActivityAt < ACTIVITY_TIMEOUT_MS;
 }
 
+// backend/src/services/archive-service.ts
+import { resolve as resolve2 } from "path";
+
+// backend/src/domain/model.ts
+var WORKTREE_META_SCHEMA_VERSION = 1;
+var WORKTREE_ARCHIVE_STATE_VERSION = 1;
+
+// backend/src/services/archive-service.ts
+function createArchiveState(entries) {
+  return {
+    schemaVersion: WORKTREE_ARCHIVE_STATE_VERSION,
+    entries: [...entries].sort((left, right) => left.path.localeCompare(right.path))
+  };
+}
+function normalizeArchivePath(path) {
+  return resolve2(path);
+}
+function buildArchivedWorktreePathSet(state) {
+  return new Set(state.entries.map((entry) => normalizeArchivePath(entry.path)));
+}
+function setArchivedWorktreeState(input) {
+  const normalizedPath = normalizeArchivePath(input.path);
+  const entries = input.state.entries.filter((entry) => normalizeArchivePath(entry.path) !== normalizedPath);
+  if (!input.archived) {
+    return createArchiveState(entries);
+  }
+  entries.push({
+    path: normalizedPath,
+    archivedAt: (input.now ?? (() => new Date))().toISOString()
+  });
+  return createArchiveState(entries);
+}
+function pruneArchivedWorktreeState(input) {
+  const validPaths = new Set(input.paths.map((path) => normalizeArchivePath(path)));
+  return createArchiveState(input.state.entries.filter((entry) => validPaths.has(normalizeArchivePath(entry.path))));
+}
+
 // backend/src/services/linear-service.ts
 var ASSIGNED_ISSUES_QUERY = `
   query AssignedIssues {
@@ -8041,9 +8078,8 @@ async function createLinearIssue(input) {
 }
 
 // backend/src/services/lifecycle-service.ts
-import { randomUUID as randomUUID2 } from "crypto";
 import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve5 } from "path";
+import { dirname as dirname4, resolve as resolve6 } from "path";
 
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
@@ -8102,6 +8138,9 @@ function getWorktreeStoragePaths(gitDir) {
     prsPath: join2(webmuxDir, "prs.json")
   };
 }
+function getProjectArchiveStatePath(gitDir) {
+  return join2(gitDir, "webmux", "archive.json");
+}
 async function ensureWorktreeStorageDirs(gitDir) {
   const paths = getWorktreeStoragePaths(gitDir);
   await mkdir2(paths.webmuxDir, { recursive: true });
@@ -8120,6 +8159,36 @@ async function writeWorktreeMeta(gitDir, meta) {
   await Bun.write(metaPath, JSON.stringify(meta, null, 2) + `
 `);
 }
+function isArchivedWorktreeEntry(raw) {
+  return isRecord2(raw) && typeof raw.path === "string" && typeof raw.archivedAt === "string";
+}
+function emptyWorktreeArchiveState() {
+  return {
+    schemaVersion: WORKTREE_ARCHIVE_STATE_VERSION,
+    entries: []
+  };
+}
+function isWorktreeArchiveState(raw) {
+  return isRecord2(raw) && typeof raw.schemaVersion === "number" && Array.isArray(raw.entries) && raw.entries.every((entry) => isArchivedWorktreeEntry(entry));
+}
+async function readWorktreeArchiveState(gitDir) {
+  const archivePath = getProjectArchiveStatePath(gitDir);
+  try {
+    const raw = await Bun.file(archivePath).json();
+    return isWorktreeArchiveState(raw) ? {
+      schemaVersion: raw.schemaVersion,
+      entries: raw.entries.map((entry) => ({ ...entry }))
+    } : emptyWorktreeArchiveState();
+  } catch {
+    return emptyWorktreeArchiveState();
+  }
+}
+async function writeWorktreeArchiveState(gitDir, state) {
+  const archivePath = getProjectArchiveStatePath(gitDir);
+  await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(archivePath, JSON.stringify(state, null, 2) + `
+`);
+}
 function buildRuntimeEnvMap(meta, extraEnv = {}, dotenvValues = {}) {
   return {
     ...dotenvValues,
@@ -8469,7 +8538,7 @@ async function ensureAgentRuntimeArtifacts(input) {
 
 // backend/src/adapters/tmux.ts
 import { createHash } from "crypto";
-import { basename, resolve as resolve2 } from "path";
+import { basename, resolve as resolve3 } from "path";
 function runTmux(args) {
   const result = Bun.spawnSync(["tmux", ...args], {
     stdout: "pipe",
@@ -8497,7 +8566,7 @@ function sanitizeTmuxNameSegment(value, maxLength = 24) {
   return trimmed || "x";
 }
 function buildProjectSessionName(projectRoot2) {
-  const resolved = resolve2(projectRoot2);
+  const resolved = resolve3(projectRoot2);
   const base = sanitizeTmuxNameSegment(basename(resolved), 18);
   const hash = createHash("sha1").update(resolved).digest("hex").slice(0, 8);
   return `wm-${base}-${hash}`;
@@ -8618,12 +8687,16 @@ function allocateServicePorts(existingMetas, services) {
 }
 
 // backend/src/services/agent-service.ts
+var DOCKER_PATH_FALLBACK = "/root/.local/bin:/usr/local/bin:/root/.bun/bin:/root/.cargo/bin";
 function quoteShell(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
 function buildRuntimeBootstrap(runtimeEnvPath) {
   return `set -a; . ${quoteShell(runtimeEnvPath)}; set +a`;
 }
+function buildDockerRuntimeBootstrap(runtimeEnvPath) {
+  return `${buildRuntimeBootstrap(runtimeEnvPath)}; export PATH="$PATH:${DOCKER_PATH_FALLBACK}"`;
+}
 function buildAgentInvocation(input) {
   if (input.agent === "codex") {
     const yoloFlag2 = input.yolo ? " --yolo" : "";
@@ -8646,11 +8719,11 @@ function buildAgentInvocation(input) {
   }
   return `claude${yoloFlag}${promptSuffix}`;
 }
-function buildAgentCommand(input) {
-  return `${buildRuntimeBootstrap(input.runtimeEnvPath)}; ${buildAgentInvocation(input)}`;
+function buildAgentCommand(input, bootstrap = buildRuntimeBootstrap) {
+  return `${bootstrap(input.runtimeEnvPath)}; ${buildAgentInvocation(input)}`;
 }
 function buildDockerExecCommand(containerName, worktreePath, command) {
-  return `docker exec -it -w ${quoteShell(worktreePath)} ${quoteShell(containerName)} bash -lc ${quoteShell(command)}`;
+  return `docker exec -it -w ${quoteShell(worktreePath)} ${quoteShell(containerName)} /bin/sh -c ${quoteShell(command)}`;
 }
 function buildManagedShellCommand(runtimeEnvPath, shellPath = Bun.env.SHELL || "/bin/bash") {
   return `bash -lc ${quoteShell(`${buildRuntimeBootstrap(runtimeEnvPath)}; exec ${quoteShell(shellPath)} -i`)}`;
@@ -8658,15 +8731,15 @@ function buildManagedShellCommand(runtimeEnvPath, shellPath = Bun.env.SHELL || "
 function buildAgentPaneCommand(input) {
   return buildAgentCommand(input);
 }
-function buildDockerShellCommand(containerName, worktreePath, runtimeEnvPath, shellPath = Bun.env.SHELL || "/bin/bash") {
-  return buildDockerExecCommand(containerName, worktreePath, `${buildRuntimeBootstrap(runtimeEnvPath)}; exec ${quoteShell(shellPath)} -i`);
+function buildDockerShellCommand(containerName, worktreePath, runtimeEnvPath, shellPath = "/bin/bash") {
+  return buildDockerExecCommand(containerName, worktreePath, `${buildDockerRuntimeBootstrap(runtimeEnvPath)}; if [ -x ${quoteShell(shellPath)} ]; then exec ${quoteShell(shellPath)} -i; elif [ -x /bin/sh ]; then exec /bin/sh -i; else echo 'webmux: no shell found in container' >&2; exit 127; fi`);
 }
 function buildDockerAgentPaneCommand(input) {
-  return buildDockerExecCommand(input.containerName, input.worktreePath, buildAgentCommand(input));
+  return buildAgentCommand(input, buildDockerRuntimeBootstrap);
 }
 
 // backend/src/services/session-service.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 function quoteShell2(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -8680,7 +8753,7 @@ function buildCommandPaneStartupCommand(template, ctx) {
   if (!template.workingDir) {
     return template.command;
   }
-  const workingDir = resolve3(resolvePaneCwd(template, ctx), template.workingDir);
+  const workingDir = resolve4(resolvePaneCwd(template, ctx), template.workingDir);
   return `cd -- ${quoteShell2(workingDir)} && ${template.command}`;
 }
 function resolvePaneStartupCommand(template, ctx) {
@@ -8760,7 +8833,7 @@ import { randomUUID } from "crypto";
 
 // backend/src/adapters/git.ts
 import { readdirSync, rmSync, statSync } from "fs";
-import { resolve as resolve4, join as join4 } from "path";
+import { resolve as resolve5, join as join4 } from "path";
 function runGit(args, cwd) {
   const result = Bun.spawnSync(["git", ...args], {
     cwd,
@@ -8794,8 +8867,8 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function isRegisteredWorktree(entries, worktreePath) {
-  const resolvedPath = resolve4(worktreePath);
-  return entries.some((entry) => resolve4(entry.path) === resolvedPath);
+  const resolvedPath = resolve5(worktreePath);
+  return entries.some((entry) => resolve5(entry.path) === resolvedPath);
 }
 function removeDirectory(path) {
   rmSync(path, {
@@ -8819,7 +8892,7 @@ function currentCheckoutRef(cwd) {
 function resolveRepoRoot(dir) {
   const direct = tryRunGit(["rev-parse", "--show-toplevel"], dir);
   if (direct.ok)
-    return resolve4(dir, direct.stdout);
+    return resolve5(dir, direct.stdout);
   let entries;
   try {
     entries = readdirSync(dir);
@@ -8836,17 +8909,17 @@ function resolveRepoRoot(dir) {
     }
     const childResult = tryRunGit(["rev-parse", "--show-toplevel"], child);
     if (childResult.ok)
-      return resolve4(child, childResult.stdout);
+      return resolve5(child, childResult.stdout);
   }
   return null;
 }
 function resolveWorktreeRoot(cwd) {
   const output = runGit(["rev-parse", "--show-toplevel"], cwd);
-  return resolve4(cwd, output);
+  return resolve5(cwd, output);
 }
 function resolveWorktreeGitDir(cwd) {
   const output = runGit(["rev-parse", "--git-dir"], cwd);
-  return resolve4(cwd, output);
+  return resolve5(cwd, output);
 }
 function parseGitWorktreePorcelain(output) {
   const entries = [];
@@ -9057,9 +9130,6 @@ class BunGitGateway {
   }
 }
 
-// backend/src/domain/model.ts
-var WORKTREE_META_SCHEMA_VERSION = 1;
-
 // backend/src/services/worktree-service.ts
 function toErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -9204,16 +9274,40 @@ function mergeManagedWorktree(opts, git = new BunGitGateway) {
   });
 }
 
-// backend/src/services/lifecycle-service.ts
-function generateBranchName() {
+// backend/src/lib/branch-name.ts
+import { randomUUID as randomUUID2 } from "crypto";
+function generateFallbackBranchName() {
   return `change-${randomUUID2().slice(0, 8)}`;
 }
+
+// backend/src/services/lifecycle-service.ts
+var DOCKER_CONTROL_HOST = "host.docker.internal";
 function toErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function stringifyStartupEnvValue(value) {
   return typeof value === "boolean" ? String(value) : value;
 }
+function trimTrailingSlashes(value) {
+  return value.replace(/\/+$/, "");
+}
+function isLoopbackHostname(hostname) {
+  return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1" || hostname === "[::1]";
+}
+function buildRuntimeControlBaseUrl(controlBaseUrl, runtime) {
+  const trimmed = trimTrailingSlashes(controlBaseUrl);
+  if (runtime !== "docker")
+    return trimmed;
+  try {
+    const url = new URL(trimmed);
+    if (isLoopbackHostname(url.hostname)) {
+      url.hostname = DOCKER_CONTROL_HOST;
+    }
+    return trimTrailingSlashes(url.toString());
+  } catch {
+    return trimmed;
+  }
+}
 function prefixAgentBranch(agent, branch) {
   return `${agent}-${branch}`;
 }
@@ -9311,9 +9405,8 @@ class LifecycleService {
   }
   async closeWorktree(branch) {
     try {
-      const resolved = await this.resolveExistingWorktree(branch);
-      this.deps.tmux.killWindow(buildProjectSessionName(this.deps.projectRoot), buildWorktreeWindowName(branch));
-      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
+      await this.resolveExistingWorktree(branch);
+      await this.closeBranchWindow(branch);
     } catch (error) {
       throw this.wrapOperationError(error);
     }
@@ -9358,6 +9451,17 @@ class LifecycleService {
       throw this.wrapOperationError(error);
     }
   }
+  async setWorktreeArchived(branch, archived) {
+    try {
+      const resolved = await this.resolveExistingWorktree(branch);
+      if (archived) {
+        await this.closeBranchWindow(branch);
+      }
+      await this.updateWorktreeArchivedState(resolved.entry.path, archived);
+    } catch (error) {
+      throw this.wrapOperationError(error);
+    }
+  }
   listAvailableBranches(options = {}) {
     const localBranches = this.listLocalBranches().filter((branch) => isValidBranchName(branch));
     const remoteBranches = options.includeRemote ? this.listRemoteBranches().filter((branch) => isValidBranchName(branch)) : [];
@@ -9370,7 +9474,7 @@ class LifecycleService {
   }
   async resolveBranch(rawBranch, prompt, mode) {
     const explicitBranch = rawBranch?.trim();
-    const branch = mode === "existing" ? explicitBranch : explicitBranch || await this.generateAutoName(prompt) || generateBranchName();
+    const branch = mode === "existing" ? explicitBranch : explicitBranch || await this.generateAutoName(prompt) || generateFallbackBranchName();
     if (!branch) {
       throw new LifecycleError("Existing branch is required", 400);
     }
@@ -9442,20 +9546,20 @@ class LifecycleService {
     return allocateServicePorts(metas, this.deps.config.services);
   }
   resolveWorktreePath(branch) {
-    return resolve5(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
+    return resolve6(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
   }
   listLocalBranches() {
-    return this.deps.git.listLocalBranches(resolve5(this.deps.projectRoot));
+    return this.deps.git.listLocalBranches(resolve6(this.deps.projectRoot));
   }
   listRemoteBranches() {
-    return this.deps.git.listRemoteBranches(resolve5(this.deps.projectRoot));
+    return this.deps.git.listRemoteBranches(resolve6(this.deps.projectRoot));
   }
   listCheckedOutBranches() {
-    return new Set(this.deps.git.listWorktrees(resolve5(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
+    return new Set(this.deps.git.listWorktrees(resolve6(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
   }
   listProjectWorktrees() {
-    const projectRoot2 = resolve5(this.deps.projectRoot);
-    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve5(entry.path) !== projectRoot2);
+    const projectRoot2 = resolve6(this.deps.projectRoot);
+    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve6(entry.path) !== projectRoot2);
   }
   async readManagedMetas() {
     const metas = await Promise.all(this.listProjectWorktrees().map(async (entry) => {
@@ -9494,7 +9598,7 @@ class LifecycleService {
       allocatedPorts: await this.allocatePorts(),
       runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: resolved.entry.path },
       dotenvValues,
-      controlUrl: this.controlUrl(),
+      controlUrl: this.controlUrl(profile.runtime),
       controlToken: await this.deps.getControlToken()
     });
   }
@@ -9515,7 +9619,7 @@ class LifecycleService {
     }, dotenvValues);
     await writeRuntimeEnv(input.gitDir, runtimeEnv);
     const controlEnv = buildControlEnvMap({
-      controlUrl: this.controlUrl(),
+      controlUrl: this.controlUrl(input.meta.runtime),
       controlToken: await this.deps.getControlToken(),
       worktreeId: input.meta.worktreeId,
       branch: input.meta.branch
@@ -9528,6 +9632,13 @@ class LifecycleService {
       controlEnv
     };
   }
+  async updateWorktreeArchivedState(path, archived) {
+    await this.deps.archiveState.setArchived(path, archived);
+  }
+  async closeBranchWindow(branch) {
+    this.deps.tmux.killWindow(buildProjectSessionName(this.deps.projectRoot), buildWorktreeWindowName(branch));
+    await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
+  }
   async materializeRuntimeSession(input) {
     if (input.profile.runtime === "docker") {
       const dockerProfile = this.requireDockerProfile(input.profile);
@@ -9570,8 +9681,6 @@ class LifecycleService {
       paneCommands: containerName ? {
         agent: buildDockerAgentPaneCommand({
           agent: input.agent,
-          containerName,
-          worktreePath: input.worktreePath,
           runtimeEnvPath: input.initialized.paths.runtimeEnvPath,
           yolo: input.profile.yolo === true,
           systemPrompt,
@@ -9632,8 +9741,8 @@ class LifecycleService {
       throw new LifecycleError(`Worktree has uncommitted changes: ${entry.branch ?? entry.path}`, 409);
     }
   }
-  controlUrl() {
-    return `${this.deps.controlBaseUrl.replace(/\/+$/, "")}/api/runtime/events`;
+  controlUrl(runtime) {
+    return `${buildRuntimeControlBaseUrl(this.deps.controlBaseUrl, runtime)}/api/runtime/events`;
   }
   async removeResolvedWorktree(resolved) {
     await this.runLifecycleHook({
@@ -9655,6 +9764,7 @@ class LifecycleService {
       deleteBranch: true,
       deleteBranchForce: true
     }, this.deps.git);
+    await this.updateWorktreeArchivedState(resolved.entry.path, false);
     await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
   }
   async runLifecycleHook(input) {
@@ -9735,7 +9845,7 @@ class LifecycleService {
         startupEnvValues: await this.buildStartupEnvValues(input.envOverrides),
         allocatedPorts: await this.allocatePorts(),
         runtimeEnvExtras: { WEBMUX_WORKTREE_PATH: worktreePath },
-        controlUrl: this.controlUrl(),
+        controlUrl: this.controlUrl(profile.runtime),
         controlToken: await this.deps.getControlToken(),
         deleteBranchOnRollback
       }, {
@@ -10440,12 +10550,13 @@ function mapCreationSnapshot(creating) {
     phase: creating.phase
   } : null;
 }
-function mapWorktreeSnapshot(state, now, creating, findLinearIssue) {
+function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue) {
   return {
     branch: state.branch,
     ...state.baseBranch ? { baseBranch: state.baseBranch } : {},
     path: state.path,
     dir: state.path,
+    archived: isArchived(state.path),
     profile: state.profile,
     agentName: state.agentName,
     mux: state.session.exists,
@@ -10460,12 +10571,13 @@ function mapWorktreeSnapshot(state, now, creating, findLinearIssue) {
     creation: mapCreationSnapshot(creating)
   };
 }
-function mapCreatingWorktreeSnapshot(creating, findLinearIssue) {
+function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue) {
   return {
     branch: creating.branch,
     ...creating.baseBranch ? { baseBranch: creating.baseBranch } : {},
     path: creating.path,
     dir: creating.path,
+    archived: isArchived(creating.path),
     profile: creating.profile,
     agentName: creating.agentName,
     mux: false,
@@ -10482,14 +10594,15 @@ function mapCreatingWorktreeSnapshot(creating, findLinearIssue) {
 }
 function buildProjectSnapshot(input) {
   const now = input.now ?? (() => new Date);
+  const isArchived = input.isArchived ?? (() => false);
   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));
+  const worktrees = runtimeWorktrees.map((state) => mapWorktreeSnapshot(state, now, creatingByBranch.get(state.branch) ?? null, isArchived, input.findLinearIssue));
   for (const creating of creatingWorktrees) {
     if (!runtimeBranches.has(creating.branch)) {
-      worktrees.push(mapCreatingWorktreeSnapshot(creating, input.findLinearIssue));
+      worktrees.push(mapCreatingWorktreeSnapshot(creating, isArchived, input.findLinearIssue));
     }
   }
   worktrees.sort((left, right) => left.branch.localeCompare(right.branch));
@@ -10867,7 +10980,7 @@ class BunPortProbe {
     this.hostnames = hostnames;
   }
   isListening(port) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       let settled = false;
       let pending = this.hostnames.length;
       const settle = (result) => {
@@ -10876,20 +10989,20 @@ class BunPortProbe {
         if (result) {
           settled = true;
           clearTimeout(timer);
-          resolve6(true);
+          resolve7(true);
           return;
         }
         pending--;
         if (pending === 0) {
           settled = true;
           clearTimeout(timer);
-          resolve6(false);
+          resolve7(false);
         }
       };
       const timer = setTimeout(() => {
         if (!settled) {
           settled = true;
-          resolve6(false);
+          resolve7(false);
         }
       }, this.timeoutMs);
       for (const hostname of this.hostnames) {
@@ -10915,6 +11028,7 @@ class BunPortProbe {
 // backend/src/services/auto-name-service.ts
 var MAX_BRANCH_LENGTH = 40;
 var DEFAULT_AUTO_NAME_MODEL = "claude-haiku-4-5-20251001";
+var AUTO_NAME_TIMEOUT_MS = 1e4;
 var DEFAULT_SYSTEM_PROMPT = [
   "Generate a concise git branch name from the task description.",
   "Return only the branch name.",
@@ -10945,17 +11059,52 @@ function normalizeGeneratedBranchName(raw) {
 function getSystemPrompt(config) {
   return config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
 }
-async function defaultSpawn(args) {
+
+class AutoNameTimeoutError extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Auto-name timed out after ${timeoutMs}ms`);
+    this.timeoutMs = timeoutMs;
+  }
+}
+async function defaultSpawn(args, options = {}) {
   const proc = Bun.spawn(args, {
     stdout: "pipe",
     stderr: "pipe"
   });
-  const [stdout, stderr, exitCode] = await Promise.all([
+  const resultPromise = Promise.all([
     new Response(proc.stdout).text(),
     new Response(proc.stderr).text(),
     proc.exited
-  ]);
-  return { exitCode, stdout, stderr };
+  ]).then(([stdout, stderr, exitCode]) => ({ exitCode, stdout, stderr }));
+  if (options.timeoutMs === undefined) {
+    return await resultPromise;
+  }
+  return await new Promise((resolve7, reject) => {
+    let settled = false;
+    const timeoutId = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      reject(new AutoNameTimeoutError(options.timeoutMs));
+    }, options.timeoutMs);
+    resultPromise.then((result) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timeoutId);
+      resolve7(result);
+    }, (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timeoutId);
+      reject(error);
+    });
+  });
 }
 function buildClaudeArgs(model, systemPrompt, prompt) {
   const args = [
@@ -10997,8 +11146,10 @@ function buildCodexArgs(model, systemPrompt, prompt) {
 
 class AutoNameService {
   spawnImpl;
+  timeoutMs;
   constructor(deps = {}) {
     this.spawnImpl = deps.spawnImpl ?? defaultSpawn;
+    this.timeoutMs = deps.timeoutMs ?? AUTO_NAME_TIMEOUT_MS;
   }
   async generateBranchName(config, task) {
     const prompt = task.trim();
@@ -11011,8 +11162,13 @@ class AutoNameService {
     const cli = config.provider === "claude" ? "claude" : "codex";
     let result;
     try {
-      result = await this.spawnImpl(args);
-    } catch {
+      result = await this.spawnImpl(args, { timeoutMs: this.timeoutMs });
+    } catch (error) {
+      if (error instanceof AutoNameTimeoutError) {
+        const fallback = generateFallbackBranchName();
+        log.warn(`[auto-name] ${cli} timed out after ${this.timeoutMs}ms; using fallback branch ${fallback}`);
+        return fallback;
+      }
       throw new Error(`'${cli}' CLI not found. Install it or check your PATH.`);
     }
     if (result.exitCode !== 0) {
@@ -11030,6 +11186,66 @@ class AutoNameService {
   }
 }
 
+// backend/src/services/archive-state-service.ts
+function archiveStatesEqual(left, right) {
+  if (left.schemaVersion !== right.schemaVersion)
+    return false;
+  if (left.entries.length !== right.entries.length)
+    return false;
+  return left.entries.every((entry, index) => entry.path === right.entries[index]?.path && entry.archivedAt === right.entries[index]?.archivedAt);
+}
+
+class ArchiveStateService {
+  gitDir;
+  mutationQueue = Promise.resolve();
+  readState;
+  writeState;
+  constructor(gitDir, deps = {}) {
+    this.gitDir = gitDir;
+    this.readState = deps.readState ?? readWorktreeArchiveState;
+    this.writeState = deps.writeState ?? writeWorktreeArchiveState;
+  }
+  async read() {
+    return await this.readState(this.gitDir);
+  }
+  async setArchived(path, archived) {
+    return await this.mutate((state) => setArchivedWorktreeState({
+      state,
+      path,
+      archived
+    }));
+  }
+  async prune(paths) {
+    return await this.mutate((state) => pruneArchivedWorktreeState({
+      state,
+      paths
+    }));
+  }
+  async mutate(transform) {
+    return await this.withMutationLock(async () => {
+      const state = await this.readState(this.gitDir);
+      const nextState = await transform(state);
+      if (!archiveStatesEqual(state, nextState)) {
+        await this.writeState(this.gitDir, nextState);
+      }
+      return nextState;
+    });
+  }
+  async withMutationLock(operation) {
+    const previous = this.mutationQueue;
+    let release = () => {};
+    this.mutationQueue = new Promise((resolve7) => {
+      release = resolve7;
+    });
+    await previous.catch(() => {});
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+}
+
 // backend/src/services/notification-service.ts
 function eventToNotificationInput(event) {
   switch (event.type) {
@@ -11294,9 +11510,9 @@ class ProjectRuntime {
 }
 
 // backend/src/services/reconciliation-service.ts
-import { basename as basename2, resolve as resolve6 } from "path";
+import { basename as basename2, resolve as resolve7 } from "path";
 function makeUnmanagedWorktreeId(path) {
-  return `unmanaged:${resolve6(path)}`;
+  return `unmanaged:${resolve7(path)}`;
 }
 function isValidPort2(port) {
   return port !== null && Number.isInteger(port) && port >= 1 && port <= 65535;
@@ -11353,7 +11569,7 @@ class ReconciliationService {
     if (!options.force && this.now() - this.lastReconciledAt < this.freshnessMs) {
       return;
     }
-    const normalizedRepoRoot = resolve6(repoRoot);
+    const normalizedRepoRoot = resolve7(repoRoot);
     const reconcilePromise = this.runReconcile(normalizedRepoRoot).then(() => {
       this.lastReconciledAt = this.now();
     });
@@ -11372,7 +11588,7 @@ class ReconciliationService {
       windows = [];
     }
     const seenWorktreeIds = new Set;
-    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve6(entry.path) !== normalizedRepoRoot);
+    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve7(entry.path) !== normalizedRepoRoot);
     const reconciledStates = await mapWithConcurrency(candidateEntries, this.concurrency, async (entry) => {
       const gitDir = this.deps.git.resolveWorktreeGitDir(entry.path);
       const meta = await readWorktreeMeta(gitDir);
@@ -11475,6 +11691,7 @@ function createWebmuxRuntime(options = {}) {
   const projectDir = projectRoot(options.projectDir ?? Bun.env.WEBMUX_PROJECT_DIR ?? process.cwd());
   const config = loadConfig(projectDir, { resolvedRoot: true });
   const git = new BunGitGateway;
+  const archiveStateService = new ArchiveStateService(git.resolveWorktreeGitDir(projectDir));
   const portProbe = new BunPortProbe;
   const tmux = new BunTmuxGateway;
   const docker = new BunDockerGateway;
@@ -11495,6 +11712,7 @@ function createWebmuxRuntime(options = {}) {
     controlBaseUrl: `http://127.0.0.1:${port}`,
     getControlToken: loadControlToken,
     config,
+    archiveState: archiveStateService,
     git,
     tmux,
     docker,
@@ -11513,6 +11731,7 @@ function createWebmuxRuntime(options = {}) {
     port,
     projectDir,
     config,
+    archiveStateService,
     git,
     portProbe,
     tmux,
@@ -11537,6 +11756,7 @@ var runtime = createWebmuxRuntime({
 var PROJECT_DIR = runtime.projectDir;
 var config = runtime.config;
 var git = runtime.git;
+var archiveStateService = runtime.archiveStateService;
 var tmux = runtime.tmux;
 var projectRuntime = runtime.projectRuntime;
 var worktreeCreationTracker = runtime.worktreeCreationTracker;
@@ -11594,7 +11814,7 @@ function getFrontendConfig() {
     startupEnvs: config.startupEnvs,
     linkedRepos: config.integrations.github.linkedRepos.map((lr) => ({
       alias: lr.alias,
-      ...lr.dir ? { dir: resolve7(PROJECT_DIR, lr.dir) } : {}
+      ...lr.dir ? { dir: resolve8(PROJECT_DIR, lr.dir) } : {}
     })),
     linearAutoCreateWorktrees: linearAutoCreateEnabled,
     autoRemoveOnMerge: autoRemoveOnMergeEnabled,
@@ -11725,9 +11945,9 @@ async function hasValidControlToken(req) {
 }
 async function getWorktreeGitDirs() {
   const gitDirs = new Map;
-  const projectRoot2 = resolve7(PROJECT_DIR);
+  const projectRoot2 = resolve8(PROJECT_DIR);
   for (const entry of git.listWorktrees(projectRoot2)) {
-    if (entry.bare || resolve7(entry.path) === projectRoot2 || !entry.branch)
+    if (entry.bare || resolve8(entry.path) === projectRoot2 || !entry.branch)
       continue;
     gitDirs.set(entry.branch, git.resolveWorktreeGitDir(entry.path));
   }
@@ -11749,10 +11969,10 @@ async function apiGetProject() {
   touchDashboardActivity();
   const linearApiKey = Bun.env.LINEAR_API_KEY;
   const linearIssuesPromise = config.integrations.linear.enabled && linearApiKey?.trim() ? fetchAssignedIssues() : Promise.resolve({ ok: true, data: [] });
-  const [, linearResult] = await Promise.all([
-    reconciliationService.reconcile(PROJECT_DIR),
-    linearIssuesPromise
-  ]);
+  await reconciliationService.reconcile(PROJECT_DIR);
+  const archiveState = await archiveStateService.prune(projectRuntime.listWorktrees().map((worktree) => worktree.path));
+  const linearResult = await linearIssuesPromise;
+  const archivedPaths = buildArchivedWorktreePathSet(archiveState);
   const linearIssues = linearResult.ok ? linearResult.data : [];
   return jsonResponse(buildProjectSnapshot({
     projectName: config.name,
@@ -11760,6 +11980,7 @@ async function apiGetProject() {
     runtime: projectRuntime,
     creatingWorktrees: worktreeCreationTracker.list(),
     notifications: runtimeNotifications.list(),
+    isArchived: (path) => archivedPaths.has(normalizeArchivePath(path)),
     findLinearIssue: (branch) => {
       const match = linearIssues.find((issue) => branchMatchesIssue(branch, issue.branchName));
       return match ? {
@@ -11937,6 +12158,21 @@ async function apiCloseWorktree(name) {
   log.debug(`[worktree:close] done name=${name}`);
   return jsonResponse({ ok: true });
 }
+async function apiSetWorktreeArchived(name, req) {
+  ensureBranchNotBusy(name);
+  const raw = await req.json();
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return errorResponse("Invalid request body", 400);
+  }
+  const body = raw;
+  if (typeof body.archived !== "boolean") {
+    return errorResponse("Missing boolean 'archived' field", 400);
+  }
+  log.info(`[worktree:archive] name=${name} archived=${body.archived}`);
+  await lifecycleService.setWorktreeArchived(name, body.archived);
+  log.debug(`[worktree:archive] done name=${name} archived=${body.archived}`);
+  return jsonResponse({ ok: true, archived: body.archived });
+}
 async function apiSendPrompt(name, req) {
   ensureBranchNotBusy(name);
   const raw = await req.json();
@@ -12009,7 +12245,7 @@ async function apiPullMain(req) {
       return errorResponse(`Unknown linked repo: ${repo}`, 404);
     if (!linkedRepo.dir)
       return errorResponse(`Linked repo "${repo}" has no dir configured`, 400);
-    const resolvedDir = resolve7(PROJECT_DIR, linkedRepo.dir);
+    const resolvedDir = resolve8(PROJECT_DIR, linkedRepo.dir);
     const repoRoot = git.resolveRepoRoot(resolvedDir);
     if (!repoRoot)
       return errorResponse(`Linked repo "${repo}" dir is not a git repository: ${resolvedDir}`, 400);
@@ -12102,7 +12338,7 @@ async function apiUploadFiles(name, req) {
     }
     const safeName = `${Date.now()}_${sanitizeFilename(entry.name)}`;
     const destPath = join7(uploadDir, safeName);
-    if (!resolve7(destPath).startsWith(uploadDir + "/")) {
+    if (!resolve8(destPath).startsWith(uploadDir + "/")) {
       return errorResponse("Invalid filename", 400);
     }
     await Bun.write(destPath, entry);
@@ -12169,6 +12405,14 @@ Bun.serve({
         return catching(`POST /api/worktrees/${name}/close`, () => apiCloseWorktree(name));
       }
     },
+    "/api/worktrees/:name/archive": {
+      PUT: (req) => {
+        const name = decodeURIComponent(req.params.name);
+        if (!isValidWorktreeName(name))
+          return errorResponse("Invalid worktree name", 400);
+        return catching(`PUT /api/worktrees/${name}/archive`, () => apiSetWorktreeArchived(name, req));
+      }
+    },
     "/api/worktrees/:name/send": {
       POST: (req) => {
         const name = decodeURIComponent(req.params.name);
@@ -12235,8 +12479,8 @@ Bun.serve({
       const url = new URL(req.url);
       const rawPath = url.pathname === "/" ? "index.html" : url.pathname;
       const filePath = join7(STATIC_DIR, rawPath);
-      const staticRoot = resolve7(STATIC_DIR);
-      if (!resolve7(filePath).startsWith(staticRoot + "/")) {
+      const staticRoot = resolve8(STATIC_DIR);
+      if (!resolve8(filePath).startsWith(staticRoot + "/")) {
         return new Response("Forbidden", { status: 403 });
       }
       const file = Bun.file(filePath);