webmux 0.32.0 → 0.34.0

package/backend/dist/server.js

@@ -6959,13 +6959,13 @@ var require_public_api = __commonJS((exports) => {
 
 // backend/src/server.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join7, resolve as resolve9 } from "path";
-import { mkdirSync } from "fs";
+import { join as join8, resolve as resolve9 } from "path";
+import { mkdirSync as mkdirSync2 } from "fs";
 import { networkInterfaces } from "os";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.32.0",
+  version: "0.34.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -10994,7 +10994,7 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// node_modules/.bun/@ts-rest+core@3.52.1+596964f7fee2c930/node_modules/@ts-rest/core/index.esm.mjs
+// node_modules/.bun/@ts-rest+core@3.52.1+94e40505b11febf1/node_modules/@ts-rest/core/index.esm.mjs
 var isZodObjectStrict = (obj) => {
   return typeof (obj === null || obj === undefined ? undefined : obj.passthrough) === "function";
 };
@@ -11178,6 +11178,7 @@ var CreateWorktreeRequestSchema = exports_external.object({
   envOverrides: exports_external.record(exports_external.string()).optional(),
   createLinearTicket: exports_external.literal(true).optional(),
   linearTitle: exports_external.string().optional(),
+  linearTeamKey: exports_external.string().trim().transform((value) => value.toUpperCase()).pipe(LinearTeamKeySchema).optional(),
   fromLinear: FromLinearInputSchema.optional(),
   source: WorktreeSourceSchema.optional(),
   oneshot: OneshotConfigSchema.optional()
@@ -11490,6 +11491,15 @@ var AgentIdParamsSchema = exports_external.object({
 var RunIdParamsSchema = exports_external.object({
   runId: NumberLikePathParamSchema
 });
+var InstanceSummarySchema = exports_external.object({
+  prefix: exports_external.string(),
+  port: exports_external.number(),
+  projectDir: exports_external.string(),
+  startedAt: exports_external.number()
+});
+var InstancesResponseSchema = exports_external.object({
+  instances: exports_external.array(InstanceSummarySchema)
+});
 
 // packages/api-contract/src/contract.ts
 var c = initContract();
@@ -11525,7 +11535,8 @@ var apiPaths = {
   setAutoRemoveOnMerge: "/api/github/auto-remove-on-merge",
   pullMain: "/api/pull-main",
   fetchCiLogs: "/api/ci-logs/:runId",
-  dismissNotification: "/api/notifications/:id/dismiss"
+  dismissNotification: "/api/notifications/:id/dismiss",
+  fetchInstances: "/api/instances"
 };
 var commonErrorResponses = {
   400: ErrorResponseSchema,
@@ -11834,6 +11845,14 @@ var apiContract = c.router({
       400: ErrorResponseSchema,
       404: ErrorResponseSchema
     }
+  },
+  fetchInstances: {
+    method: "GET",
+    path: apiPaths.fetchInstances,
+    responses: {
+      200: InstancesResponseSchema,
+      500: ErrorResponseSchema
+    }
   }
 }, {
   strictStatusCodes: true
@@ -13279,12 +13298,7 @@ function parseProjectConfig(parsed) {
         linkedRepos: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : isRecord3(parsed.integrations) && Array.isArray(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github) : [],
         autoRemoveOnMerge: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.github) && typeof parsed.integrations.github.autoRemoveOnMerge === "boolean" ? parsed.integrations.github.autoRemoveOnMerge : DEFAULT_CONFIG.integrations.github.autoRemoveOnMerge
       },
-      linear: {
-        enabled: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.enabled === "boolean" ? parsed.integrations.linear.enabled : DEFAULT_CONFIG.integrations.linear.enabled,
-        autoCreateWorktrees: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.autoCreateWorktrees === "boolean" ? parsed.integrations.linear.autoCreateWorktrees : DEFAULT_CONFIG.integrations.linear.autoCreateWorktrees,
-        createTicketOption: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.createTicketOption === "boolean" ? parsed.integrations.linear.createTicketOption : DEFAULT_CONFIG.integrations.linear.createTicketOption,
-        ...isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) && typeof parsed.integrations.linear.teamId === "string" && parsed.integrations.linear.teamId.trim() ? { teamId: parsed.integrations.linear.teamId.trim() } : {}
-      }
+      linear: parseLinearIntegration(parsed)
     },
     lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
     autoName: parseAutoName(parsed.auto_name),
@@ -13294,6 +13308,30 @@ function parseProjectConfig(parsed) {
 function defaultConfig() {
   return parseProjectConfig({});
 }
+function parseTeamKeyList(raw) {
+  if (!Array.isArray(raw))
+    return;
+  const keys = raw.filter((entry) => typeof entry === "string").map((entry) => entry.trim().toUpperCase()).filter((entry) => entry.length > 0);
+  return keys.length > 0 ? Array.from(new Set(keys)) : undefined;
+}
+var warnedLegacyLinearTeamId = false;
+function parseLinearIntegration(parsed) {
+  const defaults = DEFAULT_CONFIG.integrations.linear;
+  const linear = isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) ? parsed.integrations.linear : null;
+  if (!linear)
+    return { ...defaults };
+  if (typeof linear.teamId === "string" && !warnedLegacyLinearTeamId) {
+    warnedLegacyLinearTeamId = true;
+    log.warn("[config] integrations.linear.teamId is no longer used \u2014 the ticket team is now picked at creation time in the dashboard");
+  }
+  const watchTeams = parseTeamKeyList(linear.watchTeams);
+  return {
+    enabled: typeof linear.enabled === "boolean" ? linear.enabled : defaults.enabled,
+    autoCreateWorktrees: typeof linear.autoCreateWorktrees === "boolean" ? linear.autoCreateWorktrees : defaults.autoCreateWorktrees,
+    createTicketOption: typeof linear.createTicketOption === "boolean" ? linear.createTicketOption : defaults.createTicketOption,
+    ...watchTeams ? { watchTeams } : {}
+  };
+}
 function parseLocalLinearOverlay(parsed) {
   if (!isRecord3(parsed.integrations))
     return null;
@@ -13307,8 +13345,9 @@ function parseLocalLinearOverlay(parsed) {
     overlay.autoCreateWorktrees = linear.autoCreateWorktrees;
   if (typeof linear.createTicketOption === "boolean")
     overlay.createTicketOption = linear.createTicketOption;
-  if (typeof linear.teamId === "string" && linear.teamId.trim())
-    overlay.teamId = linear.teamId.trim();
+  const watchTeams = parseTeamKeyList(linear.watchTeams);
+  if (watchTeams)
+    overlay.watchTeams = watchTeams;
   return Object.keys(overlay).length > 0 ? overlay : null;
 }
 function parseLocalGitHubOverlay(parsed) {
@@ -15435,6 +15474,7 @@ class BunTmuxGateway {
 var INVALID_BRANCH_CHARS_RE = /[~^:?*\[\]\\]+/g;
 var UNSAFE_ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var VALID_WORKTREE_NAME_RE = /^[a-z0-9][a-z0-9\-_./]*$/;
+var VALID_INSTANCE_PREFIX_RE = /^[a-z0-9][a-z0-9\-]*$/;
 function sanitizeBranchName(raw) {
   return raw.toLowerCase().replace(/\s+/g, "-").replace(INVALID_BRANCH_CHARS_RE, "").replace(/@\{/g, "").replace(/\.{2,}/g, ".").replace(/\/{2,}/g, "/").replace(/-{2,}/g, "-").replace(/^[.\-/]+|[.\-/]+$/g, "").replace(/\.lock$/i, "");
 }
@@ -15447,6 +15487,26 @@ function isValidWorktreeName(name) {
 function isValidEnvKey(key) {
   return UNSAFE_ENV_KEY_RE.test(key);
 }
+var RESERVED_INSTANCE_PREFIXES = new Set(["api", "ws", "assets"]);
+function sanitizeInstancePrefix(raw) {
+  return raw.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function isValidInstancePrefix(value) {
+  return VALID_INSTANCE_PREFIX_RE.test(value) && !RESERVED_INSTANCE_PREFIXES.has(value);
+}
+function deriveInstancePrefix(projectDir, takenPrefixes) {
+  const basename3 = projectDir.replace(/\/+$/, "").split("/").pop() ?? "webmux";
+  const base = sanitizeInstancePrefix(basename3) || "webmux";
+  const taken = new Set([...takenPrefixes, ...RESERVED_INSTANCE_PREFIXES]);
+  if (!taken.has(base))
+    return base;
+  for (let n = 2;n < 1000; n++) {
+    const candidate = `${base}-${n}`;
+    if (!taken.has(candidate))
+      return candidate;
+  }
+  return `${base}-${Date.now()}`;
+}
 function allocateServicePorts(existingMetas, services) {
   const allocatable = services.filter((service) => service.portStart != null);
   if (allocatable.length === 0)
@@ -15498,7 +15558,7 @@ function buildDockerRuntimeBootstrap(runtimeEnvPath) {
 function buildBuiltInAgentInvocation(input) {
   const promptSuffix = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
   if (input.agent === "codex") {
-    const hooksFlag = " --enable codex_hooks";
+    const hooksFlag = " --enable hooks";
     const yoloFlag2 = input.yolo ? " --yolo" : "";
     if (input.launchMode === "resume") {
       return `codex${hooksFlag}${yoloFlag2} resume --last${promptSuffix}`;
@@ -17336,22 +17396,29 @@ var AUTO_ONESHOT_LABEL = "webmux_oneshot";
 function hasLabel(issue, name) {
   return issue.labels.some((l) => l.name.toLowerCase() === name);
 }
-function filterTriggerableIssues(issues, existingBranches, matchesLabelRule) {
+function matchesTeamFilter(issue, watchTeamKeys) {
+  if (!watchTeamKeys || watchTeamKeys.length === 0)
+    return true;
+  return watchTeamKeys.includes(issue.team.key.toUpperCase());
+}
+function filterTriggerableIssues(issues, existingBranches, matchesLabelRule, watchTeamKeys) {
   return issues.filter((issue) => {
     if (issue.state.name !== "Todo")
       return false;
     if (!matchesLabelRule(issue))
       return false;
+    if (!matchesTeamFilter(issue, watchTeamKeys))
+      return false;
     if (processedIssueIds.has(issue.id))
       return false;
     return !existingBranches.some((branch) => branchMatchesIssue(branch, issue.branchName));
   });
 }
-function filterAutoCreateIssues(issues, existingBranches) {
-  return filterTriggerableIssues(issues, existingBranches, (issue) => hasLabel(issue, AUTO_CREATE_LABEL) && !hasLabel(issue, AUTO_ONESHOT_LABEL));
+function filterAutoCreateIssues(issues, existingBranches, watchTeamKeys) {
+  return filterTriggerableIssues(issues, existingBranches, (issue) => hasLabel(issue, AUTO_CREATE_LABEL) && !hasLabel(issue, AUTO_ONESHOT_LABEL), watchTeamKeys);
 }
-function filterAutoOneshotIssues(issues, existingBranches) {
-  return filterTriggerableIssues(issues, existingBranches, (issue) => hasLabel(issue, AUTO_ONESHOT_LABEL));
+function filterAutoOneshotIssues(issues, existingBranches, watchTeamKeys) {
+  return filterTriggerableIssues(issues, existingBranches, (issue) => hasLabel(issue, AUTO_ONESHOT_LABEL), watchTeamKeys);
 }
 async function runLinearAutoCreateOnce(deps) {
   const fetchIssues = deps.fetchIssues ?? fetchAssignedIssues;
@@ -17367,8 +17434,8 @@ async function runLinearAutoCreateOnce(deps) {
   }
   const projectRoot2 = deps.projectRoot;
   const existingBranches = deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch);
-  const oneshotIssues = deps.runOneshotForIssue ? filterAutoOneshotIssues(result.data, existingBranches) : [];
-  const createIssues = filterAutoCreateIssues(result.data, existingBranches);
+  const oneshotIssues = deps.runOneshotForIssue ? filterAutoOneshotIssues(result.data, existingBranches, deps.watchTeamKeys) : [];
+  const createIssues = filterAutoCreateIssues(result.data, existingBranches, deps.watchTeamKeys);
   if (oneshotIssues.length === 0 && createIssues.length === 0) {
     log.debug(`[linear-auto-create] no new labeled issues (${result.data.length} assigned, ${existingBranches.length} worktrees)`);
     return;
@@ -19280,6 +19347,125 @@ function createWebmuxRuntime(options = {}) {
   };
 }
 
+// backend/src/adapters/instance-registry.ts
+import { mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join as join7 } from "path";
+function defaultRegistryDir() {
+  return join7(homedir(), ".webmux", "instances");
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err2) {
+    return err2?.code !== "ESRCH";
+  }
+}
+function isInstanceEntry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v = value;
+  return typeof v.prefix === "string" && isValidInstancePrefix(v.prefix) && typeof v.port === "number" && typeof v.projectDir === "string" && typeof v.pid === "number" && typeof v.startedAt === "number";
+}
+function createInstanceRegistry(dir = defaultRegistryDir()) {
+  function ensureDir() {
+    mkdirSync(dir, { recursive: true });
+  }
+  function entryPath(port) {
+    return join7(dir, `${port}.json`);
+  }
+  function readEntry(filename) {
+    try {
+      const raw = readFileSync2(join7(dir, filename), "utf8");
+      const parsed = JSON.parse(raw);
+      return isInstanceEntry(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return {
+    register(entry) {
+      ensureDir();
+      const finalPath = entryPath(entry.port);
+      const tmpPath = `${finalPath}.${process.pid}.${Date.now()}.tmp`;
+      const text = `${JSON.stringify(entry, null, 2)}
+`;
+      writeFileSync(tmpPath, text);
+      renameSync(tmpPath, finalPath);
+    },
+    deregister(port, expectedPid) {
+      if (expectedPid !== undefined) {
+        const filename = `${port}.json`;
+        const entry = readEntry(filename);
+        if (entry && entry.pid !== expectedPid) {
+          return;
+        }
+      }
+      try {
+        unlinkSync(entryPath(port));
+      } catch (err2) {
+        const code = err2?.code;
+        if (code !== "ENOENT") {
+          log.debug(`[instance-registry] deregister(${port}) failed: ${String(err2)}`);
+        }
+      }
+    },
+    listLive() {
+      let filenames;
+      try {
+        filenames = readdirSync2(dir).filter((name) => name.endsWith(".json"));
+      } catch {
+        return [];
+      }
+      const live = [];
+      for (const filename of filenames) {
+        const entry = readEntry(filename);
+        if (!entry)
+          continue;
+        if (!isAlive(entry.pid)) {
+          try {
+            unlinkSync(join7(dir, filename));
+          } catch {}
+          continue;
+        }
+        live.push(entry);
+      }
+      return live;
+    }
+  };
+}
+
+// backend/src/domain/peer-routing.ts
+function decidePeerRouting(pathname, peers, selfPort) {
+  const firstSegment = pathname.split("/")[1];
+  if (!firstSegment || !isValidInstancePrefix(firstSegment)) {
+    return { kind: "passthrough" };
+  }
+  if (RESERVED_INSTANCE_PREFIXES.has(firstSegment)) {
+    return { kind: "passthrough" };
+  }
+  const peer = peers.find((entry) => entry.prefix === firstSegment);
+  if (!peer)
+    return { kind: "passthrough" };
+  const remaining = pathname.slice(firstSegment.length + 1) || "/";
+  if (peer.port === selfPort) {
+    return { kind: "rewrite", path: remaining };
+  }
+  return { kind: "redirect", port: peer.port, path: remaining };
+}
+function resolvePeerRedirect(url, peers, selfPort) {
+  const decision = decidePeerRouting(url.pathname, peers, selfPort);
+  if (decision.kind === "passthrough")
+    return null;
+  if (decision.kind === "rewrite") {
+    url.pathname = decision.path;
+    return null;
+  }
+  const location = `${url.protocol}//${url.hostname}:${decision.port}${decision.path}${url.search}`;
+  return new Response(null, { status: 302, headers: { Location: location } });
+}
+
 // backend/src/server.ts
 var PORT = parseInt(Bun.env.PORT || "5111", 10);
 var STATIC_DIR = Bun.env.WEBMUX_STATIC_DIR || "";
@@ -19339,11 +19525,13 @@ async function runOneshotForIssue(issueId) {
 function startLinearAutoCreate() {
   if (stopLinearAutoCreate)
     return;
+  const watchTeamKeys = config.integrations.linear.watchTeams;
   stopLinearAutoCreate = startLinearAutoCreateMonitor({
     lifecycleService,
     git,
     projectRoot: PROJECT_DIR,
-    runOneshotForIssue
+    runOneshotForIssue,
+    ...watchTeamKeys && watchTeamKeys.length > 0 ? { watchTeamKeys } : {}
   });
 }
 function normalizeOneshotConfig(input) {
@@ -19875,6 +20063,7 @@ async function apiCreateWorktree(req) {
   const agents = body.agents;
   const createLinearTicket = body.createLinearTicket === true;
   const linearTitle = body.linearTitle?.trim() ? body.linearTitle.trim() : undefined;
+  const linearTeamKey = body.linearTeamKey;
   const mode = body.mode;
   const selectedAgents = agents ? agents : agent ? [agent] : [config.workspace.defaultAgent];
   if (baseBranch && !isValidBranchName(baseBranch)) {
@@ -19932,14 +20121,17 @@ ${resolvedPrompt}` : conversationContext;
     if (!title) {
       return errorResponse("Linear ticket title could not be derived from the prompt", 400);
     }
-    const teamId = config.integrations.linear.teamId;
-    if (!teamId) {
-      return errorResponse("Linear teamId is not configured", 503);
+    if (!linearTeamKey) {
+      return errorResponse('Linear team is required to create a ticket. Provide `linearTeamKey` (e.g. "ENG").', 400);
+    }
+    const teamResult = await fetchTeamByKey(linearTeamKey);
+    if (!teamResult.ok) {
+      return errorResponse(teamResult.error, teamResult.status);
     }
     const linearResult = await createLinearIssue({
       title,
       description: resolvedPrompt ?? "",
-      teamId
+      teamId: teamResult.data.id
     });
     if (!linearResult.ok) {
       return errorResponse(linearResult.error, 502);
@@ -20306,7 +20498,7 @@ async function apiUploadFiles(name, req) {
   if (entries.length === 0)
     return errorResponse("No files provided", 400);
   const uploadDir = `/tmp/webmux-uploads/${sanitizeFilename(name)}`;
-  mkdirSync(uploadDir, { recursive: true });
+  mkdirSync2(uploadDir, { recursive: true });
   const results = [];
   for (const entry of entries) {
     if (!(entry instanceof File))
@@ -20318,7 +20510,7 @@ async function apiUploadFiles(name, req) {
       return errorResponse(`File too large: ${entry.name} (max 10MB)`, 400);
     }
     const safeName = `${Date.now()}_${sanitizeFilename(entry.name)}`;
-    const destPath = join7(uploadDir, safeName);
+    const destPath = join8(uploadDir, safeName);
     if (!resolve9(destPath).startsWith(uploadDir + "/")) {
       return errorResponse("Invalid filename", 400);
     }
@@ -20377,368 +20569,446 @@ function parseAgentIdParam(params) {
     data: agentId
   };
 }
-Bun.serve({
-  port: PORT,
-  idleTimeout: 255,
-  routes: {
-    [apiPaths.streamAgentsWorktreeConversation]: (req, server) => {
-      const branch = decodeURIComponent(req.params.name);
-      return server.upgrade(req, { data: { kind: "agents", branch, conversationId: null, unsubscribe: null } }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
-    },
-    "/ws/:worktree": (req, server) => {
-      const branch = decodeURIComponent(req.params.worktree);
-      return server.upgrade(req, {
-        data: { kind: "terminal", branch, worktreeId: null, attachId: null, attached: false }
-      }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
-    },
-    [apiPaths.fetchConfig]: {
-      GET: () => jsonResponse(getFrontendConfig())
-    },
-    [apiPaths.fetchAvailableBranches]: {
-      GET: (req) => catching("GET /api/branches", () => apiListBranches(req))
-    },
-    [apiPaths.fetchBaseBranches]: {
-      GET: () => catching("GET /api/base-branches", () => apiListBaseBranches())
-    },
-    [apiPaths.fetchProject]: {
-      GET: () => catching("GET /api/project", () => apiGetProject())
-    },
-    [apiPaths.fetchAgents]: {
-      GET: () => catching("GET /api/agents", () => apiListAgents()),
-      POST: (req) => catching("POST /api/agents", () => apiCreateAgent(req))
-    },
-    [apiPaths.validateAgent]: {
-      POST: (req) => catching("POST /api/agents/validate", () => apiValidateAgent(req))
-    },
-    [apiPaths.updateAgent]: {
-      PUT: (req) => {
-        const parsed = parseAgentIdParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        return catching("PUT /api/agents/:id", () => apiUpdateAgent(parsed.data, req));
+function startServer(port) {
+  return Bun.serve({
+    port,
+    idleTimeout: 255,
+    routes: {
+      [apiPaths.streamAgentsWorktreeConversation]: (req, server) => {
+        const branch = decodeURIComponent(req.params.name);
+        return server.upgrade(req, { data: { kind: "agents", branch, conversationId: null, unsubscribe: null } }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
       },
-      DELETE: (req) => {
-        const parsed = parseAgentIdParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        return catching("DELETE /api/agents/:id", () => apiDeleteAgent(parsed.data));
-      }
-    },
-    [apiPaths.attachAgentsWorktreeConversation]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST ${apiPaths.attachAgentsWorktreeConversation}`, () => apiAttachAgentsWorktree(name));
-      }
-    },
-    [apiPaths.fetchAgentsWorktreeConversationHistory]: {
-      GET: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`GET ${apiPaths.fetchAgentsWorktreeConversationHistory}`, () => apiGetAgentsWorktreeHistory(name));
-      }
-    },
-    [apiPaths.sendAgentsWorktreeConversationMessage]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST ${apiPaths.sendAgentsWorktreeConversationMessage}`, () => apiSendAgentsWorktreeMessage(name, req));
-      }
-    },
-    [apiPaths.interruptAgentsWorktreeConversation]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST ${apiPaths.interruptAgentsWorktreeConversation}`, () => apiInterruptAgentsWorktree(name));
-      }
-    },
-    "/api/runtime/events": {
-      POST: (req) => catching("POST /api/runtime/events", () => apiRuntimeEvent(req))
-    },
-    [apiPaths.fetchWorktrees]: {
-      GET: () => catching("GET /api/worktrees", () => apiGetWorktrees()),
-      POST: (req) => catching("POST /api/worktrees", () => apiCreateWorktree(req))
-    },
-    [apiPaths.removeWorktree]: {
-      DELETE: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`DELETE /api/worktrees/${name}`, () => apiDeleteWorktree(name));
-      }
-    },
-    [apiPaths.openWorktree]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/open`, () => apiOpenWorktree(name, req));
-      }
-    },
-    "/api/worktrees/:name/terminal-launch": {
-      GET: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`GET /api/worktrees/${name}/terminal-launch`, () => apiGetNativeTerminalLaunch(name));
-      }
-    },
-    [apiPaths.closeWorktree]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/close`, () => apiCloseWorktree(name));
-      }
-    },
-    [apiPaths.setWorktreeArchived]: {
-      PUT: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`PUT /api/worktrees/${name}/archive`, () => apiSetWorktreeArchived(name, req));
-      }
-    },
-    [apiPaths.postWorktreeToLinear]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/linear/post`, () => apiPostWorktreeToLinear(name, req));
-      }
-    },
-    [apiPaths.syncWorktreePrs]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/sync-prs`, () => apiSyncWorktreePrs(name));
-      }
-    },
-    [apiPaths.setWorktreeLabel]: {
-      PUT: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`PUT /api/worktrees/${name}/label`, () => apiSetWorktreeLabel(name, req));
-      }
-    },
-    [apiPaths.sendWorktreePrompt]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/send`, () => apiSendPrompt(name, req));
-      }
-    },
-    "/api/worktrees/:name/upload": {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/upload`, () => apiUploadFiles(name, req));
-      }
-    },
-    [apiPaths.mergeWorktree]: {
-      POST: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`POST /api/worktrees/${name}/merge`, () => apiMergeWorktree(name));
-      }
-    },
-    [apiPaths.fetchWorktreeDiff]: {
-      GET: (req) => {
-        const parsed = parseWorktreeNameParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const name = parsed.data;
-        return catching(`GET /api/worktrees/${name}/diff`, () => apiGetWorktreeDiff(name));
-      }
-    },
-    [apiPaths.fetchLinearIssues]: {
-      GET: () => catching("GET /api/linear/issues", () => apiGetLinearIssues())
-    },
-    [apiPaths.setLinearAutoCreate]: {
-      PUT: (req) => catching("PUT /api/linear/auto-create", () => apiSetLinearAutoCreate(req))
-    },
-    [apiPaths.setAutoRemoveOnMerge]: {
-      PUT: (req) => catching("PUT /api/github/auto-remove-on-merge", () => apiSetAutoRemoveOnMerge(req))
-    },
-    [apiPaths.pullMain]: {
-      POST: (req) => catching("POST /api/pull-main", () => apiPullMain(req))
-    },
-    [apiPaths.fetchCiLogs]: {
-      GET: (req) => {
-        const parsed = parseRunIdParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        return catching(`GET /api/ci-logs/${parsed.data}`, () => apiCiLogs(parsed.data));
+      "/ws/:worktree": (req, server) => {
+        const branch = decodeURIComponent(req.params.worktree);
+        return server.upgrade(req, {
+          data: { kind: "terminal", branch, worktreeId: null, attachId: null, attached: false }
+        }) ? undefined : new Response("WebSocket upgrade failed", { status: 400 });
+      },
+      [apiPaths.fetchConfig]: {
+        GET: () => jsonResponse(getFrontendConfig())
+      },
+      [apiPaths.fetchAvailableBranches]: {
+        GET: (req) => catching("GET /api/branches", () => apiListBranches(req))
+      },
+      [apiPaths.fetchBaseBranches]: {
+        GET: () => catching("GET /api/base-branches", () => apiListBaseBranches())
+      },
+      [apiPaths.fetchProject]: {
+        GET: () => catching("GET /api/project", () => apiGetProject())
+      },
+      [apiPaths.fetchAgents]: {
+        GET: () => catching("GET /api/agents", () => apiListAgents()),
+        POST: (req) => catching("POST /api/agents", () => apiCreateAgent(req))
+      },
+      [apiPaths.validateAgent]: {
+        POST: (req) => catching("POST /api/agents/validate", () => apiValidateAgent(req))
+      },
+      [apiPaths.updateAgent]: {
+        PUT: (req) => {
+          const parsed = parseAgentIdParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          return catching("PUT /api/agents/:id", () => apiUpdateAgent(parsed.data, req));
+        },
+        DELETE: (req) => {
+          const parsed = parseAgentIdParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          return catching("DELETE /api/agents/:id", () => apiDeleteAgent(parsed.data));
+        }
+      },
+      [apiPaths.attachAgentsWorktreeConversation]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST ${apiPaths.attachAgentsWorktreeConversation}`, () => apiAttachAgentsWorktree(name));
+        }
+      },
+      [apiPaths.fetchAgentsWorktreeConversationHistory]: {
+        GET: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`GET ${apiPaths.fetchAgentsWorktreeConversationHistory}`, () => apiGetAgentsWorktreeHistory(name));
+        }
+      },
+      [apiPaths.sendAgentsWorktreeConversationMessage]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST ${apiPaths.sendAgentsWorktreeConversationMessage}`, () => apiSendAgentsWorktreeMessage(name, req));
+        }
+      },
+      [apiPaths.interruptAgentsWorktreeConversation]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST ${apiPaths.interruptAgentsWorktreeConversation}`, () => apiInterruptAgentsWorktree(name));
+        }
+      },
+      "/api/runtime/events": {
+        POST: (req) => catching("POST /api/runtime/events", () => apiRuntimeEvent(req))
+      },
+      [apiPaths.fetchWorktrees]: {
+        GET: () => catching("GET /api/worktrees", () => apiGetWorktrees()),
+        POST: (req) => catching("POST /api/worktrees", () => apiCreateWorktree(req))
+      },
+      [apiPaths.removeWorktree]: {
+        DELETE: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`DELETE /api/worktrees/${name}`, () => apiDeleteWorktree(name));
+        }
+      },
+      [apiPaths.openWorktree]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/open`, () => apiOpenWorktree(name, req));
+        }
+      },
+      "/api/worktrees/:name/terminal-launch": {
+        GET: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`GET /api/worktrees/${name}/terminal-launch`, () => apiGetNativeTerminalLaunch(name));
+        }
+      },
+      [apiPaths.closeWorktree]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/close`, () => apiCloseWorktree(name));
+        }
+      },
+      [apiPaths.setWorktreeArchived]: {
+        PUT: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`PUT /api/worktrees/${name}/archive`, () => apiSetWorktreeArchived(name, req));
+        }
+      },
+      [apiPaths.postWorktreeToLinear]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/linear/post`, () => apiPostWorktreeToLinear(name, req));
+        }
+      },
+      [apiPaths.syncWorktreePrs]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/sync-prs`, () => apiSyncWorktreePrs(name));
+        }
+      },
+      [apiPaths.setWorktreeLabel]: {
+        PUT: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`PUT /api/worktrees/${name}/label`, () => apiSetWorktreeLabel(name, req));
+        }
+      },
+      [apiPaths.sendWorktreePrompt]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/send`, () => apiSendPrompt(name, req));
+        }
+      },
+      "/api/worktrees/:name/upload": {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/upload`, () => apiUploadFiles(name, req));
+        }
+      },
+      [apiPaths.mergeWorktree]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/merge`, () => apiMergeWorktree(name));
+        }
+      },
+      [apiPaths.fetchWorktreeDiff]: {
+        GET: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`GET /api/worktrees/${name}/diff`, () => apiGetWorktreeDiff(name));
+        }
+      },
+      [apiPaths.fetchLinearIssues]: {
+        GET: () => catching("GET /api/linear/issues", () => apiGetLinearIssues())
+      },
+      [apiPaths.setLinearAutoCreate]: {
+        PUT: (req) => catching("PUT /api/linear/auto-create", () => apiSetLinearAutoCreate(req))
+      },
+      [apiPaths.setAutoRemoveOnMerge]: {
+        PUT: (req) => catching("PUT /api/github/auto-remove-on-merge", () => apiSetAutoRemoveOnMerge(req))
+      },
+      [apiPaths.pullMain]: {
+        POST: (req) => catching("POST /api/pull-main", () => apiPullMain(req))
+      },
+      [apiPaths.fetchCiLogs]: {
+        GET: (req) => {
+          const parsed = parseRunIdParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          return catching(`GET /api/ci-logs/${parsed.data}`, () => apiCiLogs(parsed.data));
+        }
+      },
+      "/api/notifications/stream": {
+        GET: () => runtimeNotifications.stream()
+      },
+      [apiPaths.dismissNotification]: {
+        POST: (req) => {
+          const parsed = parseNotificationIdParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const id = parsed.data;
+          if (!runtimeNotifications.dismiss(id))
+            return errorResponse("Not found", 404);
+          return jsonResponse({ ok: true });
+        }
+      },
+      [apiPaths.fetchInstances]: {
+        GET: () => jsonResponse({
+          instances: instanceRegistry.listLive().filter((entry) => entry.port !== BOUND_PORT).map((entry) => ({
+            prefix: entry.prefix,
+            port: entry.port,
+            projectDir: entry.projectDir,
+            startedAt: entry.startedAt
+          }))
+        })
       }
     },
-    "/api/notifications/stream": {
-      GET: () => runtimeNotifications.stream()
-    },
-    [apiPaths.dismissNotification]: {
-      POST: (req) => {
-        const parsed = parseNotificationIdParam(req.params);
-        if (!parsed.ok)
-          return parsed.response;
-        const id = parsed.data;
-        if (!runtimeNotifications.dismiss(id))
-          return errorResponse("Not found", 404);
-        return jsonResponse({ ok: true });
-      }
-    }
-  },
-  async fetch(req) {
-    const url = new URL(req.url);
-    if (STATIC_DIR) {
-      const rawPath = url.pathname === "/" ? "index.html" : url.pathname;
-      const filePath = join7(STATIC_DIR, rawPath);
-      const staticRoot = resolve9(STATIC_DIR);
-      if (!resolve9(filePath).startsWith(staticRoot + "/")) {
-        return new Response("Forbidden", { status: 403 });
-      }
-      const file = Bun.file(filePath);
-      if (await file.exists()) {
-        const headers = rawPath.startsWith("/assets/") ? { "Cache-Control": "public, max-age=31536000, immutable" } : {};
-        return new Response(file, { headers });
-      }
-      return new Response(Bun.file(join7(STATIC_DIR, "index.html")), {
-        headers: { "Cache-Control": "no-cache" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
-  },
-  websocket: {
-    idleTimeout: 255,
-    sendPings: true,
-    data: {},
-    open(ws) {
-      const data = ws.data;
-      if (data.kind === "terminal") {
-        log.debug(`[ws] open branch=${data.branch}`);
-        return;
+    async fetch(req) {
+      const url = new URL(req.url);
+      const peerRedirect = resolvePeerRedirect(url, instanceRegistry.listLive(), BOUND_PORT);
+      if (peerRedirect)
+        return peerRedirect;
+      if (STATIC_DIR) {
+        const rawPath = url.pathname === "/" ? "index.html" : url.pathname;
+        const filePath = join8(STATIC_DIR, rawPath);
+        const staticRoot = resolve9(STATIC_DIR);
+        if (!resolve9(filePath).startsWith(staticRoot + "/")) {
+          return new Response("Forbidden", { status: 403 });
+        }
+        const file = Bun.file(filePath);
+        if (await file.exists()) {
+          const headers = rawPath.startsWith("/assets/") ? { "Cache-Control": "public, max-age=31536000, immutable" } : {};
+          return new Response(file, { headers });
+        }
+        return new Response(Bun.file(join8(STATIC_DIR, "index.html")), {
+          headers: { "Cache-Control": "no-cache" }
+        });
       }
-      log.debug(`[ws:agents] open branch=${data.branch}`);
-      openAgentsSocket(ws, data);
+      return new Response("Not Found", { status: 404 });
     },
-    async message(ws, message) {
-      const data = ws.data;
-      if (data.kind === "agents") {
-        log.debug(`[ws:agents] ignoring inbound message branch=${data.branch}`);
-        return;
-      }
-      const msg = parseWsMessage(message);
-      if (!msg) {
-        sendWs(ws, { type: "error", message: "malformed message" });
-        return;
-      }
-      const { branch } = data;
-      switch (msg.type) {
-        case "input": {
-          const attachId = getAttachedSessionId(data, ws);
-          if (!attachId)
-            return;
-          if (projectRuntime.getWorktreeByBranch(branch)?.oneshot) {
-            disarmOneshotIfArmed(branch, "terminal-ws-input");
-          }
-          write(attachId, msg.data);
-          break;
+    websocket: {
+      idleTimeout: 255,
+      sendPings: true,
+      data: {},
+      open(ws) {
+        const data = ws.data;
+        if (data.kind === "terminal") {
+          log.debug(`[ws] open branch=${data.branch}`);
+          return;
         }
-        case "sendKeys": {
-          const attachId = getAttachedSessionId(data, ws);
-          if (!attachId)
-            return;
-          if (projectRuntime.getWorktreeByBranch(branch)?.oneshot) {
-            disarmOneshotIfArmed(branch, "terminal-ws-send-keys");
-          }
-          await sendKeys(attachId, msg.hexBytes);
-          break;
+        log.debug(`[ws:agents] open branch=${data.branch}`);
+        openAgentsSocket(ws, data);
+      },
+      async message(ws, message) {
+        const data = ws.data;
+        if (data.kind === "agents") {
+          log.debug(`[ws:agents] ignoring inbound message branch=${data.branch}`);
+          return;
+        }
+        const msg = parseWsMessage(message);
+        if (!msg) {
+          sendWs(ws, { type: "error", message: "malformed message" });
+          return;
         }
-        case "selectPane":
-          {
+        const { branch } = data;
+        switch (msg.type) {
+          case "input": {
             const attachId = getAttachedSessionId(data, ws);
             if (!attachId)
               return;
-            log.debug(`[ws] selectPane pane=${msg.pane} branch=${branch} attachId=${attachId}`);
-            await selectPane(attachId, msg.pane);
-          }
-          break;
-        case "resize":
-          if (!data.attached) {
-            data.attached = true;
-            log.debug(`[ws] first resize (attaching) branch=${branch} cols=${msg.cols} rows=${msg.rows}`);
-            try {
-              if (msg.initialPane !== undefined) {
-                log.debug(`[ws] initialPane=${msg.initialPane} branch=${branch}`);
-              }
-              const terminalWorktree = await resolveTerminalWorktree(branch);
-              const attachId = `${terminalWorktree.worktreeId}:${randomUUID3()}`;
-              data.worktreeId = terminalWorktree.worktreeId;
-              data.attachId = attachId;
-              await attach(attachId, terminalWorktree.attachTarget, msg.cols, msg.rows, msg.initialPane);
-              const { onData, onExit } = makeCallbacks(ws);
-              setCallbacks(attachId, onData, onExit);
-              const scrollback = getScrollback(attachId);
-              log.debug(`[ws] attached branch=${branch} worktreeId=${terminalWorktree.worktreeId} attachId=${attachId} scrollback=${scrollback.length} bytes`);
-              if (scrollback.length > 0) {
-                sendWs(ws, { type: "scrollback", data: scrollback });
-              }
-            } catch (err2) {
-              const errMsg = err2 instanceof Error ? err2.message : String(err2);
-              data.attached = false;
-              data.worktreeId = null;
-              data.attachId = null;
-              log.error(`[ws] attach failed branch=${branch}: ${errMsg}`);
-              sendWs(ws, { type: "error", message: errMsg });
-              ws.close(1011, errMsg.slice(0, 123));
+            if (projectRuntime.getWorktreeByBranch(branch)?.oneshot) {
+              disarmOneshotIfArmed(branch, "terminal-ws-input");
             }
-          } else {
+            write(attachId, msg.data);
+            break;
+          }
+          case "sendKeys": {
             const attachId = getAttachedSessionId(data, ws);
             if (!attachId)
               return;
-            await resize(attachId, msg.cols, msg.rows);
+            if (projectRuntime.getWorktreeByBranch(branch)?.oneshot) {
+              disarmOneshotIfArmed(branch, "terminal-ws-send-keys");
+            }
+            await sendKeys(attachId, msg.hexBytes);
+            break;
           }
-          break;
-      }
-    },
-    async close(ws, code, reason) {
-      const data = ws.data;
-      if (data.kind === "agents") {
-        log.debug(`[ws:agents] close branch=${data.branch} code=${code} reason=${reason}`);
-        data.unsubscribe?.();
-        data.unsubscribe = null;
-        return;
+          case "selectPane":
+            {
+              const attachId = getAttachedSessionId(data, ws);
+              if (!attachId)
+                return;
+              log.debug(`[ws] selectPane pane=${msg.pane} branch=${branch} attachId=${attachId}`);
+              await selectPane(attachId, msg.pane);
+            }
+            break;
+          case "resize":
+            if (!data.attached) {
+              data.attached = true;
+              log.debug(`[ws] first resize (attaching) branch=${branch} cols=${msg.cols} rows=${msg.rows}`);
+              try {
+                if (msg.initialPane !== undefined) {
+                  log.debug(`[ws] initialPane=${msg.initialPane} branch=${branch}`);
+                }
+                const terminalWorktree = await resolveTerminalWorktree(branch);
+                const attachId = `${terminalWorktree.worktreeId}:${randomUUID3()}`;
+                data.worktreeId = terminalWorktree.worktreeId;
+                data.attachId = attachId;
+                await attach(attachId, terminalWorktree.attachTarget, msg.cols, msg.rows, msg.initialPane);
+                const { onData, onExit } = makeCallbacks(ws);
+                setCallbacks(attachId, onData, onExit);
+                const scrollback = getScrollback(attachId);
+                log.debug(`[ws] attached branch=${branch} worktreeId=${terminalWorktree.worktreeId} attachId=${attachId} scrollback=${scrollback.length} bytes`);
+                if (scrollback.length > 0) {
+                  sendWs(ws, { type: "scrollback", data: scrollback });
+                }
+              } catch (err2) {
+                const errMsg = err2 instanceof Error ? err2.message : String(err2);
+                data.attached = false;
+                data.worktreeId = null;
+                data.attachId = null;
+                log.error(`[ws] attach failed branch=${branch}: ${errMsg}`);
+                sendWs(ws, { type: "error", message: errMsg });
+                ws.close(1011, errMsg.slice(0, 123));
+              }
+            } else {
+              const attachId = getAttachedSessionId(data, ws);
+              if (!attachId)
+                return;
+              await resize(attachId, msg.cols, msg.rows);
+            }
+            break;
+        }
+      },
+      async close(ws, code, reason) {
+        const data = ws.data;
+        if (data.kind === "agents") {
+          log.debug(`[ws:agents] close branch=${data.branch} code=${code} reason=${reason}`);
+          data.unsubscribe?.();
+          data.unsubscribe = null;
+          return;
+        }
+        log.debug(`[ws] close branch=${data.branch} code=${code} reason=${reason} attached=${data.attached} worktreeId=${data.worktreeId} attachId=${data.attachId}`);
+        if (data.attachId) {
+          clearCallbacks(data.attachId);
+          await detach(data.attachId);
+        }
       }
-      log.debug(`[ws] close branch=${data.branch} code=${code} reason=${reason} attached=${data.attached} worktreeId=${data.worktreeId} attachId=${data.attachId}`);
-      if (data.attachId) {
-        clearCallbacks(data.attachId);
-        await detach(data.attachId);
+    }
+  });
+}
+function actualPort(server, requested) {
+  return server.port ?? requested;
+}
+var MAX_INCREMENTAL_BIND_ATTEMPTS = 100;
+var PORT_STRICT = Bun.env.WEBMUX_PORT_STRICT === "1";
+function bindServer() {
+  if (PORT_STRICT) {
+    try {
+      return actualPort(startServer(PORT), PORT);
+    } catch (err2) {
+      const code = err2?.code;
+      if (code === "EADDRINUSE") {
+        log.error(`[serve] port ${PORT} is in use and was set explicitly; drop --port / PORT to let webmux pick a free port`);
       }
+      throw err2;
     }
   }
+  let candidate = PORT;
+  for (let attempt = 0;attempt < MAX_INCREMENTAL_BIND_ATTEMPTS; attempt++) {
+    try {
+      const server = startServer(candidate);
+      if (attempt > 0)
+        log.info(`[serve] port ${PORT} in use; bound to ${actualPort(server, candidate)}`);
+      return actualPort(server, candidate);
+    } catch (err2) {
+      const code = err2?.code;
+      if (code !== "EADDRINUSE")
+        throw err2;
+      candidate += 1;
+    }
+  }
+  log.info(`[serve] ports ${PORT}..${PORT + MAX_INCREMENTAL_BIND_ATTEMPTS - 1} all in use; falling back to an OS-picked port`);
+  return actualPort(startServer(0), 0);
+}
+var BOUND_PORT = bindServer();
+var instanceRegistry = createInstanceRegistry();
+var explicitPrefix = Bun.env.WEBMUX_PREFIX?.trim();
+var livePeers = instanceRegistry.listLive();
+var takenPrefixes = livePeers.map((peer) => peer.prefix);
+var INSTANCE_PREFIX = explicitPrefix && isValidInstancePrefix(explicitPrefix) ? explicitPrefix : deriveInstancePrefix(PROJECT_DIR, takenPrefixes);
+var selfEntry = {
+  prefix: INSTANCE_PREFIX,
+  port: BOUND_PORT,
+  projectDir: PROJECT_DIR,
+  pid: process.pid,
+  startedAt: Date.now()
+};
+instanceRegistry.register(selfEntry);
+log.info(`[serve] registered instance prefix=${INSTANCE_PREFIX} port=${BOUND_PORT}`);
+function deregisterSelf() {
+  try {
+    instanceRegistry.deregister(BOUND_PORT, process.pid);
+  } catch {}
+}
+process.on("SIGINT", () => {
+  deregisterSelf();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  deregisterSelf();
+  process.exit(0);
 });
+process.on("exit", deregisterSelf);
 var tmuxCheck = Bun.spawnSync(["tmux", "list-sessions"], { stdout: "pipe", stderr: "pipe" });
 if (tmuxCheck.exitCode !== 0) {
   Bun.spawnSync(["tmux", "new-session", "-d", "-s", "0"]);
@@ -20765,12 +21035,12 @@ startOneshotWatcher({
 if (config.workspace.autoPull.enabled) {
   startAutoPullMonitor({ git, projectRoot: PROJECT_DIR, mainBranch: config.workspace.mainBranch }, config.workspace.autoPull.intervalSeconds * 1000);
 }
-log.info(`Dev Dashboard API running at http://localhost:${PORT}`);
+log.info(`Dev Dashboard API running at http://localhost:${BOUND_PORT}`);
 var nets = networkInterfaces();
 for (const addrs of Object.values(nets)) {
   for (const a of addrs ?? []) {
     if (a.family === "IPv4" && !a.internal) {
-      log.info(`  Network: http://${a.address}:${PORT}`);
+      log.info(`  Network: http://${a.address}:${BOUND_PORT}`);
     }
   }
 }