webmux 0.28.1 → 0.30.0

package/backend/dist/server.js

@@ -6933,7 +6933,7 @@ var require_public_api = __commonJS((exports) => {
 
 // backend/src/server.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { join as join8, resolve as resolve8 } from "path";
+import { join as join8, resolve as resolve9 } from "path";
 import { mkdirSync } from "fs";
 import { networkInterfaces } from "os";
 
@@ -10999,9 +10999,45 @@ var EnabledResponseSchema = exports_external.object({
   ok: exports_external.literal(true),
   enabled: exports_external.boolean()
 });
-var AgentKindSchema = exports_external.enum(["claude", "codex"]);
-var CreateWorktreeAgentSelectionSchema = exports_external.enum(["claude", "codex", "both"]);
+var BuiltInAgentIdSchema = exports_external.enum(["claude", "codex"]);
+var AgentIdSchema = exports_external.string().trim().min(1);
 var WorktreeCreateModeSchema = exports_external.enum(["new", "existing"]);
+var AgentCapabilitiesSchema = exports_external.object({
+  terminal: exports_external.literal(true),
+  inAppChat: exports_external.boolean(),
+  conversationHistory: exports_external.boolean(),
+  interrupt: exports_external.boolean(),
+  resume: exports_external.boolean()
+});
+var AgentSummarySchema = exports_external.object({
+  id: AgentIdSchema,
+  label: exports_external.string(),
+  kind: exports_external.enum(["builtin", "custom"]),
+  capabilities: AgentCapabilitiesSchema
+});
+var AgentDetailsSchema = exports_external.object({
+  id: AgentIdSchema,
+  label: exports_external.string(),
+  kind: exports_external.enum(["builtin", "custom"]),
+  capabilities: AgentCapabilitiesSchema,
+  startCommand: exports_external.string().nullable(),
+  resumeCommand: exports_external.string().nullable()
+});
+var AgentListResponseSchema = exports_external.object({
+  agents: exports_external.array(AgentDetailsSchema)
+});
+var UpsertCustomAgentRequestSchema = exports_external.object({
+  label: exports_external.string().trim().min(1),
+  startCommand: exports_external.string().trim().min(1),
+  resumeCommand: exports_external.string().trim().optional()
+});
+var AgentResponseSchema = exports_external.object({
+  agent: AgentDetailsSchema
+});
+var ValidateCustomAgentResponseSchema = exports_external.object({
+  normalizedId: AgentIdSchema,
+  warnings: exports_external.array(exports_external.string())
+});
 var WorktreeCreationPhaseSchema = exports_external.enum([
   "creating_worktree",
   "preparing_runtime",
@@ -11027,7 +11063,8 @@ var CreateWorktreeRequestSchema = exports_external.object({
   branch: exports_external.string().optional(),
   baseBranch: exports_external.string().optional(),
   profile: exports_external.string().optional(),
-  agent: CreateWorktreeAgentSelectionSchema.optional(),
+  agent: AgentIdSchema.optional(),
+  agents: exports_external.array(AgentIdSchema).min(1).optional(),
   prompt: exports_external.string().optional(),
   envOverrides: exports_external.record(exports_external.string()).optional(),
   createLinearTicket: exports_external.literal(true).optional(),
@@ -11158,7 +11195,8 @@ var ProjectWorktreeSnapshotSchema = exports_external.object({
   dir: exports_external.string(),
   archived: exports_external.boolean(),
   profile: exports_external.string().nullable(),
-  agentName: AgentKindSchema.nullable(),
+  agentName: AgentIdSchema.nullable(),
+  agentLabel: exports_external.string().nullable(),
   mux: exports_external.boolean(),
   dirty: exports_external.boolean(),
   unpushed: exports_external.boolean(),
@@ -11203,7 +11241,8 @@ var AgentsUiWorktreeSummarySchema = exports_external.object({
   path: exports_external.string(),
   archived: exports_external.boolean(),
   profile: exports_external.string().nullable(),
-  agentName: AgentKindSchema.nullable(),
+  agentName: AgentIdSchema.nullable(),
+  agentLabel: exports_external.string().nullable(),
   mux: exports_external.boolean(),
   status: exports_external.string(),
   dirty: exports_external.boolean(),
@@ -11295,7 +11334,9 @@ var AppConfigSchema = exports_external.object({
   name: exports_external.string(),
   services: exports_external.array(ServiceConfigSchema),
   profiles: exports_external.array(ProfileConfigSchema),
+  agents: exports_external.array(AgentSummarySchema),
   defaultProfileName: exports_external.string(),
+  defaultAgentId: BuiltInAgentIdSchema,
   autoName: exports_external.boolean(),
   linearCreateTicketOption: exports_external.boolean(),
   startupEnvs: exports_external.record(exports_external.union([exports_external.string(), exports_external.boolean()])),
@@ -11314,6 +11355,9 @@ var WorktreeNameParamsSchema = exports_external.object({
 var NotificationIdParamsSchema = exports_external.object({
   id: NumberLikePathParamSchema
 });
+var AgentIdParamsSchema = exports_external.object({
+  id: AgentIdSchema
+});
 var RunIdParamsSchema = exports_external.object({
   runId: NumberLikePathParamSchema
 });
@@ -11325,6 +11369,11 @@ var apiPaths = {
   fetchAvailableBranches: "/api/branches",
   fetchBaseBranches: "/api/base-branches",
   fetchProject: "/api/project",
+  fetchAgents: "/api/agents",
+  createAgent: "/api/agents",
+  updateAgent: "/api/agents/:id",
+  deleteAgent: "/api/agents/:id",
+  validateAgent: "/api/agents/validate",
   attachAgentsWorktreeConversation: "/api/agents/worktrees/:name/attach",
   fetchAgentsWorktreeConversationHistory: "/api/agents/worktrees/:name/history",
   sendAgentsWorktreeConversationMessage: "/api/agents/worktrees/:name/messages",
@@ -11389,6 +11438,60 @@ var apiContract = c.router({
       502: ErrorResponseSchema
     }
   },
+  fetchAgents: {
+    method: "GET",
+    path: apiPaths.fetchAgents,
+    responses: {
+      200: AgentListResponseSchema,
+      500: ErrorResponseSchema
+    }
+  },
+  createAgent: {
+    method: "POST",
+    path: apiPaths.createAgent,
+    body: UpsertCustomAgentRequestSchema,
+    responses: {
+      200: AgentResponseSchema,
+      400: ErrorResponseSchema,
+      409: ErrorResponseSchema,
+      500: ErrorResponseSchema
+    }
+  },
+  updateAgent: {
+    method: "PUT",
+    path: apiPaths.updateAgent,
+    pathParams: AgentIdParamsSchema,
+    body: UpsertCustomAgentRequestSchema,
+    responses: {
+      200: AgentResponseSchema,
+      400: ErrorResponseSchema,
+      404: ErrorResponseSchema,
+      409: ErrorResponseSchema,
+      500: ErrorResponseSchema
+    }
+  },
+  deleteAgent: {
+    method: "DELETE",
+    path: apiPaths.deleteAgent,
+    pathParams: AgentIdParamsSchema,
+    body: c.noBody(),
+    responses: {
+      200: OkResponseSchema,
+      400: ErrorResponseSchema,
+      404: ErrorResponseSchema,
+      500: ErrorResponseSchema
+    }
+  },
+  validateAgent: {
+    method: "POST",
+    path: apiPaths.validateAgent,
+    body: UpsertCustomAgentRequestSchema,
+    responses: {
+      200: ValidateCustomAgentResponseSchema,
+      400: ErrorResponseSchema,
+      500: ErrorResponseSchema
+    }
+  },
   attachAgentsWorktreeConversation: {
     method: "POST",
     path: apiPaths.attachAgentsWorktreeConversation,
@@ -11866,7 +11969,7 @@ async function sendPrompt(worktreeId, target, text, paneIndex = 0, preamble, sub
   if (load.exitCode !== 0) {
     return { ok: false, error: `load-buffer failed${load.stderr ? `: ${load.stderr}` : ""}` };
   }
-  const paste = await tmuxExec(["tmux", "paste-buffer", "-b", bufferName, "-t", paneTarget, "-d"]);
+  const paste = await tmuxExec(["tmux", "paste-buffer", "-rp", "-b", bufferName, "-t", paneTarget, "-d"]);
   if (paste.exitCode !== 0) {
     return { ok: false, error: `paste-buffer failed${paste.stderr ? `: ${paste.stderr}` : ""}` };
   }
@@ -12691,6 +12794,7 @@ var DEFAULT_CONFIG = {
       panes: clonePanes(DEFAULT_PANES)
     }
   },
+  agents: {},
   services: [],
   startupEnvs: {},
   integrations: {
@@ -12808,6 +12912,38 @@ function parseProfiles(raw, includeDefaultProfile) {
   }
   return profiles;
 }
+function cloneAgentConfig(agent) {
+  return { ...agent };
+}
+function cloneAgents(agents) {
+  return Object.fromEntries(Object.entries(agents).map(([id, agent]) => [id, cloneAgentConfig(agent)]));
+}
+function parseCustomAgent(raw) {
+  if (!isRecord3(raw))
+    return null;
+  if (typeof raw.label !== "string" || !raw.label.trim())
+    return null;
+  if (typeof raw.startCommand !== "string" || !raw.startCommand.trim())
+    return null;
+  return {
+    label: raw.label.trim(),
+    startCommand: raw.startCommand.trim(),
+    ...typeof raw.resumeCommand === "string" && raw.resumeCommand.trim() ? { resumeCommand: raw.resumeCommand.trim() } : {}
+  };
+}
+function parseCustomAgents(raw) {
+  if (!isRecord3(raw))
+    return {};
+  return Object.entries(raw).reduce((acc, [id, value]) => {
+    if (!id.trim())
+      return acc;
+    const parsed = parseCustomAgent(value);
+    if (parsed) {
+      acc[id.trim()] = parsed;
+    }
+    return acc;
+  }, {});
+}
 function parseServices(raw) {
   if (!Array.isArray(raw))
     return [];
@@ -12900,6 +13036,7 @@ function parseProjectConfig(parsed) {
       autoPull: isRecord3(parsed.workspace) ? parseAutoPull(parsed.workspace.autoPull) : DEFAULT_CONFIG.workspace.autoPull
     },
     profiles: parseProfiles(parsed.profiles, true),
+    agents: {},
     services: parseServices(parsed.services),
     startupEnvs: parseStartupEnvs(parsed.startupEnvs),
     integrations: {
@@ -12967,20 +13104,21 @@ function loadLocalProjectConfigOverlay(root) {
   try {
     const text = readLocalConfigFile(root).trim();
     if (!text) {
-      return { worktreeRoot: null, profiles: {}, lifecycleHooks: {}, linear: null, github: null, autoPull: null };
+      return { worktreeRoot: null, profiles: {}, agents: {}, lifecycleHooks: {}, linear: null, github: null, autoPull: null };
     }
     const parsed = parseConfigDocument(text);
     const ws = isRecord3(parsed.workspace) ? parsed.workspace : null;
     return {
       worktreeRoot: ws && typeof ws.worktreeRoot === "string" ? ws.worktreeRoot : null,
       profiles: parseProfiles(parsed.profiles, false),
+      agents: parseCustomAgents(parsed.agents),
       lifecycleHooks: parseLifecycleHooks(parsed.lifecycleHooks),
       linear: parseLocalLinearOverlay(parsed),
       github: parseLocalGitHubOverlay(parsed),
       autoPull: parseLocalAutoPullOverlay(parsed)
     };
   } catch {
-    return { worktreeRoot: null, profiles: {}, lifecycleHooks: {}, linear: null, github: null, autoPull: null };
+    return { worktreeRoot: null, profiles: {}, agents: {}, lifecycleHooks: {}, linear: null, github: null, autoPull: null };
   }
 }
 function mergeHookCommand(projectCommand, localCommand) {
@@ -13040,12 +13178,15 @@ function loadConfig(dir, options = {}) {
       ...cloneProfiles(projectConfig.profiles),
       ...cloneProfiles(localOverlay.profiles)
     },
+    agents: {
+      ...cloneAgents(projectConfig.agents),
+      ...cloneAgents(localOverlay.agents)
+    },
     lifecycleHooks: mergeLifecycleHooks(projectConfig.lifecycleHooks, localOverlay.lifecycleHooks),
     integrations
   };
 }
-async function persistLocalLinearConfig(dir, changes) {
-  const root = projectRoot(dir);
+function readLocalConfigDocument(root) {
   const localPath = join2(root, ".webmux.local.yaml");
   let existing = {};
   try {
@@ -13053,6 +13194,11 @@ async function persistLocalLinearConfig(dir, changes) {
     if (text)
       existing = parseConfigDocument(text);
   } catch {}
+  return { localPath, existing };
+}
+async function persistLocalLinearConfig(dir, changes) {
+  const root = projectRoot(dir);
+  const { localPath, existing } = readLocalConfigDocument(root);
   const integrations = isRecord3(existing.integrations) ? { ...existing.integrations } : {};
   const linear = isRecord3(integrations.linear) ? { ...integrations.linear } : {};
   Object.assign(linear, changes);
@@ -13062,13 +13208,7 @@ async function persistLocalLinearConfig(dir, changes) {
 }
 async function persistLocalGitHubConfig(dir, changes) {
   const root = projectRoot(dir);
-  const localPath = join2(root, ".webmux.local.yaml");
-  let existing = {};
-  try {
-    const text = readFileSync(localPath, "utf8").trim();
-    if (text)
-      existing = parseConfigDocument(text);
-  } catch {}
+  const { localPath, existing } = readLocalConfigDocument(root);
   const integrations = isRecord3(existing.integrations) ? { ...existing.integrations } : {};
   const github = isRecord3(integrations.github) ? { ...integrations.github } : {};
   Object.assign(github, changes);
@@ -13076,6 +13216,33 @@ async function persistLocalGitHubConfig(dir, changes) {
   existing.integrations = integrations;
   await Bun.write(localPath, $stringify(existing));
 }
+async function persistLocalCustomAgent(dir, agentId, agent) {
+  const root = projectRoot(dir);
+  const { localPath, existing } = readLocalConfigDocument(root);
+  const agents = isRecord3(existing.agents) ? { ...existing.agents } : {};
+  agents[agentId] = {
+    label: agent.label,
+    startCommand: agent.startCommand,
+    ...agent.resumeCommand ? { resumeCommand: agent.resumeCommand } : {}
+  };
+  existing.agents = agents;
+  await Bun.write(localPath, $stringify(existing));
+}
+async function removeLocalCustomAgent(dir, agentId) {
+  const root = projectRoot(dir);
+  const { localPath, existing } = readLocalConfigDocument(root);
+  if (!isRecord3(existing.agents) || !(agentId in existing.agents)) {
+    return;
+  }
+  const agents = { ...existing.agents };
+  delete agents[agentId];
+  if (Object.keys(agents).length === 0) {
+    delete existing.agents;
+  } else {
+    existing.agents = agents;
+  }
+  await Bun.write(localPath, $stringify(existing));
+}
 function expandTemplate(template, env) {
   return template.replace(/\$\{(\w+)\}/g, (_, key) => env[key] ?? "");
 }
@@ -13208,6 +13375,188 @@ function pruneArchivedWorktreeState(input) {
   return createArchiveState(input.state.entries.filter((entry) => validPaths.has(normalizeArchivePath(entry.path))));
 }
 
+// backend/src/services/agent-chat-service.ts
+var CODEX_SUBMIT_DELAY_MS = 200;
+function resolveAgentTerminalSubmitDelayMs(input) {
+  if (!input.agentId || !input.agent || input.agent.kind !== "builtin")
+    return 0;
+  return input.agent.implementation.agent === "codex" ? CODEX_SUBMIT_DELAY_MS : 0;
+}
+function resolveAgentChatSupport(input) {
+  if (!input.agentId) {
+    return {
+      ok: false,
+      error: "This worktree has no agent configured",
+      status: 409
+    };
+  }
+  if (!input.agent) {
+    return {
+      ok: false,
+      error: `Unknown agent: ${input.agentId}`,
+      status: 404
+    };
+  }
+  const agentLabel = input.agentLabel ?? input.agent.label;
+  if (!input.agent.capabilities.inAppChat || !input.agent.capabilities.conversationHistory) {
+    return {
+      ok: false,
+      error: `${agentLabel} does not support in-app chat`,
+      status: 409
+    };
+  }
+  if (input.action === "interrupt" && !input.agent.capabilities.interrupt) {
+    return {
+      ok: false,
+      error: `${agentLabel} cannot be interrupted from the dashboard`,
+      status: 409
+    };
+  }
+  if (input.agent.kind === "builtin") {
+    return {
+      ok: true,
+      data: {
+        provider: input.agent.implementation.agent,
+        submitDelayMs: resolveAgentTerminalSubmitDelayMs(input)
+      }
+    };
+  }
+  return {
+    ok: false,
+    error: `Dashboard chat is not available for ${agentLabel}`,
+    status: 409
+  };
+}
+
+// backend/src/services/agent-registry.ts
+var BUILTIN_AGENT_DEFINITIONS = [
+  {
+    id: "claude",
+    label: "Claude",
+    kind: "builtin",
+    capabilities: {
+      terminal: true,
+      inAppChat: true,
+      conversationHistory: true,
+      interrupt: true,
+      resume: true
+    },
+    implementation: {
+      type: "builtin",
+      agent: "claude"
+    }
+  },
+  {
+    id: "codex",
+    label: "Codex",
+    kind: "builtin",
+    capabilities: {
+      terminal: true,
+      inAppChat: true,
+      conversationHistory: true,
+      interrupt: true,
+      resume: true
+    },
+    implementation: {
+      type: "builtin",
+      agent: "codex"
+    }
+  }
+];
+function cloneCapabilities(capabilities) {
+  return { ...capabilities };
+}
+function isBuiltInAgentId(agentId) {
+  return BUILTIN_AGENT_DEFINITIONS.some((agent) => agent.id === agentId);
+}
+function normalizeCustomAgentId(label) {
+  const normalized = label.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return normalized || "agent";
+}
+function cloneDefinition(definition) {
+  if (definition.kind === "builtin") {
+    return {
+      ...definition,
+      capabilities: cloneCapabilities(definition.capabilities),
+      implementation: { ...definition.implementation }
+    };
+  }
+  return {
+    ...definition,
+    capabilities: cloneCapabilities(definition.capabilities),
+    implementation: {
+      type: "custom",
+      config: { ...definition.implementation.config }
+    }
+  };
+}
+function buildCustomAgentDefinition(id, config) {
+  return {
+    id,
+    label: config.label,
+    kind: "custom",
+    capabilities: {
+      terminal: true,
+      inAppChat: false,
+      conversationHistory: false,
+      interrupt: false,
+      resume: config.resumeCommand !== undefined
+    },
+    implementation: {
+      type: "custom",
+      config: { ...config }
+    }
+  };
+}
+function listAgentDefinitions(config) {
+  const builtInIds = new Set(BUILTIN_AGENT_DEFINITIONS.map((agent) => agent.id));
+  const customDefinitions = Object.entries(config.agents).filter(([id]) => !builtInIds.has(id)).sort(([leftId, left], [rightId, right]) => {
+    const labelCompare = left.label.localeCompare(right.label);
+    return labelCompare !== 0 ? labelCompare : leftId.localeCompare(rightId);
+  }).map(([id, agent]) => buildCustomAgentDefinition(id, agent));
+  return [
+    ...BUILTIN_AGENT_DEFINITIONS.map((definition) => cloneDefinition(definition)),
+    ...customDefinitions
+  ];
+}
+function getAgentDefinition(config, agentId) {
+  const definition = listAgentDefinitions(config).find((agent) => agent.id === agentId);
+  return definition ?? null;
+}
+function listAgentSummaries(config) {
+  return listAgentDefinitions(config).map((agent) => ({
+    id: agent.id,
+    label: agent.label,
+    kind: agent.kind,
+    capabilities: cloneCapabilities(agent.capabilities)
+  }));
+}
+function listAgentDetails(config) {
+  return listAgentDefinitions(config).map((agent) => ({
+    id: agent.id,
+    label: agent.label,
+    kind: agent.kind,
+    capabilities: cloneCapabilities(agent.capabilities),
+    startCommand: agent.kind === "custom" ? agent.implementation.config.startCommand : null,
+    resumeCommand: agent.kind === "custom" ? agent.implementation.config.resumeCommand ?? null : null
+  }));
+}
+
+// backend/src/services/agent-validation-service.ts
+function validateCustomAgentInput(input) {
+  const warnings = [];
+  if (!input.startCommand.includes("${PROMPT}") && !input.startCommand.includes("${SYSTEM_PROMPT}")) {
+    warnings.push("Start command does not reference ${PROMPT} or ${SYSTEM_PROMPT}; initial prompts will not be passed automatically");
+  }
+  if (!input.resumeCommand?.trim()) {
+    warnings.push("Resume command is not configured; reopening the worktree will restart the agent");
+  }
+  return {
+    normalizedId: normalizeCustomAgentId(input.label),
+    warnings
+  };
+}
+
 // backend/src/services/linear-service.ts
 var ASSIGNED_ISSUES_QUERY = `
   query AssignedIssues {
@@ -13537,11 +13886,11 @@ async function createLinearIssue(input) {
 
 // backend/src/services/lifecycle-service.ts
 import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname4, resolve as resolve6 } from "path";
+import { dirname as dirname4, resolve as resolve7 } from "path";
 
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
 
 // backend/src/adapters/fs.ts
 import { mkdir as mkdir2 } from "fs/promises";
@@ -13754,6 +14103,7 @@ async function writeWorktreePrs(gitDir, prs) {
 }
 
 // backend/src/adapters/agent-runtime.ts
+var GENERATED_CODEX_HOOKS_EXCLUDE = ".codex/hooks.json";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -13772,6 +14122,7 @@ from pathlib import Path
 
 
 CONTROL_ENV_PATH = Path(__file__).resolve().with_name("control.env")
+CONTROL_REQUEST_TIMEOUT_SECONDS = 2
 
 
 def read_control_env():
@@ -13801,6 +14152,7 @@ def build_parser():
 
     status_changed = subparsers.add_parser("status-changed")
     status_changed.add_argument("--lifecycle", choices=["starting", "running", "idle", "stopped"], required=True)
+    status_changed.add_argument("--best-effort", action="store_true")
 
     pr_opened = subparsers.add_parser("pr-opened")
     pr_opened.add_argument("--url")
@@ -13810,6 +14162,11 @@ def build_parser():
 
     subparsers.add_parser("claude-user-prompt-submit")
     subparsers.add_parser("claude-post-tool-use")
+    subparsers.add_parser("codex-session-start")
+    subparsers.add_parser("codex-user-prompt-submit")
+    subparsers.add_parser("codex-permission-request")
+    subparsers.add_parser("codex-post-tool-use")
+    subparsers.add_parser("codex-stop")
 
     return parser
 
@@ -13852,6 +14209,41 @@ def read_hook_payload():
     return parsed if isinstance(parsed, dict) else {}
 
 
+def iter_string_values(value):
+    if isinstance(value, str):
+        yield value
+        return
+    if isinstance(value, dict):
+        for child in value.values():
+            yield from iter_string_values(child)
+        return
+    if isinstance(value, list):
+        for child in value:
+            yield from iter_string_values(child)
+
+
+def find_pr_url(value):
+    for text in iter_string_values(value):
+        match = re.search(r"https://github\\.com/[^\\s\\"]+/pull/\\d+", text)
+        if match:
+            return match.group(0)
+    return None
+
+
+def maybe_send_pr_opened(hook_payload, control_env):
+    tool_name = hook_payload.get("tool_name")
+    tool_input = hook_payload.get("tool_input")
+    if not isinstance(tool_input, dict) or tool_name != "Bash":
+        return True
+
+    command = tool_input.get("command")
+    if not isinstance(command, str) or "gh pr create" not in command:
+        return True
+
+    pr_args = argparse.Namespace(url=find_pr_url(hook_payload.get("tool_response")))
+    return send_payload(build_payload("pr-opened", pr_args, control_env), control_env)
+
+
 def send_payload(payload, control_env):
     request = urllib.request.Request(
         control_env["WEBMUX_CONTROL_URL"],
@@ -13864,7 +14256,7 @@ def send_payload(payload, control_env):
     )
 
     try:
-        with urllib.request.urlopen(request, timeout=10) as response:
+        with urllib.request.urlopen(request, timeout=CONTROL_REQUEST_TIMEOUT_SECONDS) as response:
             if response.status < 200 or response.status >= 300:
                 print(f"control endpoint returned HTTP {response.status}", file=sys.stderr)
                 return False
@@ -13898,34 +14290,40 @@ def main():
         print(f"missing control env keys: {', '.join(missing)}", file=sys.stderr)
         return 1
 
+    if parsed.command == "codex-session-start":
+        send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="idle"), control_env), control_env)
+        return 0
+
+    if parsed.command == "codex-user-prompt-submit":
+        send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="running"), control_env), control_env)
+        return 0
+
     if parsed.command == "claude-user-prompt-submit":
         if not send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="running"), control_env), control_env):
             return 1
         return 0
 
-    if parsed.command == "claude-post-tool-use":
-        hook_payload = read_hook_payload()
-        tool_name = hook_payload.get("tool_name")
-        tool_input = hook_payload.get("tool_input")
-        if not isinstance(tool_input, dict) or tool_name != "Bash":
-            return 0
+    if parsed.command == "codex-permission-request":
+        send_payload(build_payload("status-changed", argparse.Namespace(lifecycle="idle"), control_env), control_env)
+        return 0
 
-        command = tool_input.get("command")
-        if not isinstance(command, str) or "gh pr create" not in command:
-            return 0
+    if parsed.command == "codex-post-tool-use":
+        hook_payload = read_hook_payload()
+        maybe_send_pr_opened(hook_payload, control_env)
+        return 0
 
-        pr_args = argparse.Namespace(url=None)
-        tool_response = hook_payload.get("tool_response")
-        if isinstance(tool_response, str):
-            match = re.search(r"https://github\\.com/[^\\s\\"]+/pull/\\d+", tool_response)
-            if match:
-                pr_args.url = match.group(0)
+    if parsed.command == "claude-post-tool-use":
+        hook_payload = read_hook_payload()
+        return 0 if maybe_send_pr_opened(hook_payload, control_env) else 1
 
-        return 0 if send_payload(build_payload("pr-opened", pr_args, control_env), control_env) else 1
+    if parsed.command == "codex-stop":
+        send_payload(build_payload("agent-stopped", parsed, control_env), control_env)
+        print(json.dumps({}))
+        return 0
 
     payload = build_payload(parsed.command, parsed, control_env)
     if not send_payload(payload, control_env):
-        return 1
+        return 0 if getattr(parsed, "best_effort", False) else 1
 
     return 0
 
@@ -13995,6 +14393,81 @@ function buildClaudeHookSettings(input) {
     }
   };
 }
+function buildCodexHookSettings(input) {
+  const statusCommand = `${shellQuote(input.agentCtlPath)} status-changed --lifecycle running --best-effort`;
+  return {
+    hooks: {
+      SessionStart: [
+        {
+          matcher: "startup|resume|clear",
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-session-start`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      UserPromptSubmit: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-user-prompt-submit`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      PermissionRequest: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-permission-request`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      PreToolUse: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: statusCommand,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      PostToolUse: [
+        {
+          matcher: "Bash",
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-post-tool-use`,
+              timeout: 30
+            }
+          ]
+        }
+      ],
+      Stop: [
+        {
+          hooks: [
+            {
+              type: "command",
+              command: `${shellQuote(input.agentCtlPath)} codex-stop`,
+              timeout: 30
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
 async function mergeClaudeSettings(settingsPath, hookSettings) {
   let existing = {};
   try {
@@ -14014,13 +14487,77 @@ async function mergeClaudeSettings(settingsPath, hookSettings) {
   await Bun.write(settingsPath, JSON.stringify(merged, null, 2) + `
 `);
 }
+function commandStartsWithAgentCtl(command, agentCtlPath) {
+  const trimmedCommand = command.trimStart();
+  const quotedAgentCtlPath = shellQuote(agentCtlPath);
+  return trimmedCommand === agentCtlPath || trimmedCommand.startsWith(`${agentCtlPath} `) || trimmedCommand === quotedAgentCtlPath || trimmedCommand.startsWith(`${quotedAgentCtlPath} `);
+}
+function isWebmuxHookGroup(group, agentCtlPath) {
+  if (!isRecord5(group) || !Array.isArray(group.hooks))
+    return false;
+  return group.hooks.some((hook) => isRecord5(hook) && typeof hook.command === "string" && commandStartsWithAgentCtl(hook.command, agentCtlPath));
+}
+async function mergeCodexHooksFile(hooksPath, hookSettings, agentCtlPath) {
+  let existing = {};
+  try {
+    const file = Bun.file(hooksPath);
+    if (await file.exists()) {
+      const parsed = await file.json();
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        existing = parsed;
+      }
+    }
+  } catch {
+    existing = {};
+  }
+  const existingHooks = isRecord5(existing.hooks) ? existing.hooks : {};
+  const mergedHooks = { ...existingHooks };
+  for (const [eventName, groups] of Object.entries(hookSettings)) {
+    const eventGroups = existingHooks[eventName];
+    const preservedGroups = Array.isArray(eventGroups) ? eventGroups.filter((group) => !isWebmuxHookGroup(group, agentCtlPath)) : [];
+    mergedHooks[eventName] = [...preservedGroups, ...groups];
+  }
+  await Bun.write(hooksPath, JSON.stringify({ ...existing, hooks: mergedHooks }, null, 2) + `
+`);
+}
+async function resolveGitCommonDir(gitDir) {
+  try {
+    const commonDir = (await Bun.file(join4(gitDir, "commondir")).text()).trim();
+    if (!commonDir)
+      return gitDir;
+    return commonDir.startsWith("/") ? commonDir : resolve3(gitDir, commonDir);
+  } catch {
+    return gitDir;
+  }
+}
+async function ensureGeneratedCodexHooksIgnored(gitDir) {
+  const commonDir = await resolveGitCommonDir(gitDir);
+  const excludePath = join4(commonDir, "info", "exclude");
+  let existing = "";
+  try {
+    existing = await Bun.file(excludePath).text();
+  } catch {
+    existing = "";
+  }
+  const lines = existing.split(/\r?\n/).map((line) => line.trim());
+  if (lines.includes(GENERATED_CODEX_HOOKS_EXCLUDE))
+    return;
+  await mkdir3(dirname3(excludePath), { recursive: true });
+  const separator = existing.length > 0 && !existing.endsWith(`
+`) ? `
+` : "";
+  await Bun.write(excludePath, `${existing}${separator}${GENERATED_CODEX_HOOKS_EXCLUDE}
+`);
+}
 async function ensureAgentRuntimeArtifacts(input) {
   const storagePaths = getWorktreeStoragePaths(input.gitDir);
   const artifacts = {
     agentCtlPath: join4(storagePaths.webmuxDir, "webmux-agentctl"),
-    claudeSettingsPath: join4(input.worktreePath, ".claude", "settings.local.json")
+    claudeSettingsPath: join4(input.worktreePath, ".claude", "settings.local.json"),
+    codexHooksPath: join4(input.worktreePath, ".codex", "hooks.json")
   };
   await mkdir3(dirname3(artifacts.claudeSettingsPath), { recursive: true });
+  await mkdir3(dirname3(artifacts.codexHooksPath), { recursive: true });
   await Bun.write(artifacts.agentCtlPath, buildAgentCtlScript());
   await chmod2(artifacts.agentCtlPath, 493);
   const hookSettings = buildClaudeHookSettings(artifacts);
@@ -14029,12 +14566,14 @@ async function ensureAgentRuntimeArtifacts(input) {
     throw new Error("Invalid Claude hook settings");
   }
   await mergeClaudeSettings(artifacts.claudeSettingsPath, hooks);
+  await ensureGeneratedCodexHooksIgnored(input.gitDir);
+  await mergeCodexHooksFile(artifacts.codexHooksPath, buildCodexHookSettings(artifacts).hooks, artifacts.agentCtlPath);
   return artifacts;
 }
 
 // backend/src/adapters/tmux.ts
 import { createHash } from "crypto";
-import { basename as basename2, resolve as resolve3 } from "path";
+import { basename as basename2, resolve as resolve4 } from "path";
 function runTmux(args) {
   const result = Bun.spawnSync(["tmux", ...args], {
     stdout: "pipe",
@@ -14062,7 +14601,7 @@ function sanitizeTmuxNameSegment(value, maxLength = 24) {
   return trimmed || "x";
 }
 function buildProjectSessionName(projectRoot2) {
-  const resolved = resolve3(projectRoot2);
+  const resolved = resolve4(projectRoot2);
   const base = sanitizeTmuxNameSegment(basename2(resolved), 18);
   const hash = createHash("sha1").update(resolved).digest("hex").slice(0, 8);
   return `wm-${base}-${hash}`;
@@ -14184,6 +14723,14 @@ 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";
+var CUSTOM_AGENT_TEMPLATE_VARS = {
+  PROMPT: "WEBMUX_AGENT_PROMPT",
+  SYSTEM_PROMPT: "WEBMUX_AGENT_SYSTEM_PROMPT",
+  WORKTREE_PATH: "WEBMUX_AGENT_WORKTREE_PATH",
+  REPO_PATH: "WEBMUX_AGENT_REPO_PATH",
+  BRANCH: "WEBMUX_AGENT_BRANCH",
+  PROFILE: "WEBMUX_AGENT_PROFILE"
+};
 function quoteShell(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -14193,17 +14740,18 @@ function buildRuntimeBootstrap(runtimeEnvPath) {
 function buildDockerRuntimeBootstrap(runtimeEnvPath) {
   return `${buildRuntimeBootstrap(runtimeEnvPath)}; export PATH="$PATH:${DOCKER_PATH_FALLBACK}"`;
 }
-function buildAgentInvocation(input) {
+function buildBuiltInAgentInvocation(input) {
   if (input.agent === "codex") {
+    const hooksFlag = " --enable codex_hooks";
     const yoloFlag2 = input.yolo ? " --yolo" : "";
     if (input.launchMode === "resume") {
-      return `codex${yoloFlag2} resume --last`;
+      return `codex${hooksFlag}${yoloFlag2} resume --last`;
     }
     const promptSuffix2 = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
     if (input.systemPrompt) {
-      return `codex${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix2}`;
+      return `codex${hooksFlag}${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix2}`;
     }
-    return `codex${yoloFlag2}${promptSuffix2}`;
+    return `codex${hooksFlag}${yoloFlag2}${promptSuffix2}`;
   }
   const yoloFlag = input.yolo ? " --dangerously-skip-permissions" : "";
   if (input.launchMode === "resume") {
@@ -14215,6 +14763,47 @@ function buildAgentInvocation(input) {
   }
   return `claude${yoloFlag}${promptSuffix}`;
 }
+function renderCustomCommandTemplate(template) {
+  return template.replaceAll("${PROMPT}", `$${CUSTOM_AGENT_TEMPLATE_VARS.PROMPT}`).replaceAll("${SYSTEM_PROMPT}", `$${CUSTOM_AGENT_TEMPLATE_VARS.SYSTEM_PROMPT}`).replaceAll("${WORKTREE_PATH}", `$${CUSTOM_AGENT_TEMPLATE_VARS.WORKTREE_PATH}`).replaceAll("${REPO_PATH}", `$${CUSTOM_AGENT_TEMPLATE_VARS.REPO_PATH}`).replaceAll("${BRANCH}", `$${CUSTOM_AGENT_TEMPLATE_VARS.BRANCH}`).replaceAll("${PROFILE}", `$${CUSTOM_AGENT_TEMPLATE_VARS.PROFILE}`);
+}
+function buildCustomAgentExports(input) {
+  const envEntries = [
+    [CUSTOM_AGENT_TEMPLATE_VARS.PROMPT, input.prompt ?? ""],
+    [CUSTOM_AGENT_TEMPLATE_VARS.SYSTEM_PROMPT, input.systemPrompt ?? ""],
+    [CUSTOM_AGENT_TEMPLATE_VARS.WORKTREE_PATH, input.worktreePath],
+    [CUSTOM_AGENT_TEMPLATE_VARS.REPO_PATH, input.repoRoot],
+    [CUSTOM_AGENT_TEMPLATE_VARS.BRANCH, input.branch],
+    [CUSTOM_AGENT_TEMPLATE_VARS.PROFILE, input.profileName]
+  ];
+  return envEntries.map(([key, value]) => `export ${key}=${quoteShell(value)}`).join("; ");
+}
+function buildCustomAgentInvocation(input) {
+  const template = input.launchMode === "resume" && input.agent.implementation.config.resumeCommand ? input.agent.implementation.config.resumeCommand : input.agent.implementation.config.startCommand;
+  const exports = buildCustomAgentExports(input);
+  const renderedCommand = renderCustomCommandTemplate(template);
+  return `${exports}; ${renderedCommand}`;
+}
+function buildAgentInvocation(input) {
+  if (input.agent.kind === "builtin") {
+    return buildBuiltInAgentInvocation({
+      agent: input.agent.implementation.agent,
+      yolo: input.yolo,
+      systemPrompt: input.systemPrompt,
+      prompt: input.prompt,
+      launchMode: input.launchMode
+    });
+  }
+  return buildCustomAgentInvocation({
+    agent: input.agent,
+    systemPrompt: input.systemPrompt,
+    prompt: input.prompt,
+    worktreePath: input.worktreePath,
+    repoRoot: input.repoRoot,
+    branch: input.branch,
+    profileName: input.profileName,
+    launchMode: input.launchMode
+  });
+}
 function buildAgentCommand(input, bootstrap = buildRuntimeBootstrap) {
   return `${bootstrap(input.runtimeEnvPath)}; ${buildAgentInvocation(input)}`;
 }
@@ -14235,7 +14824,7 @@ function buildDockerAgentPaneCommand(input) {
 }
 
 // backend/src/services/session-service.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 function quoteShell2(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -14249,7 +14838,7 @@ function buildCommandPaneStartupCommand(template, ctx) {
   if (!template.workingDir) {
     return template.command;
   }
-  const workingDir = resolve4(resolvePaneCwd(template, ctx), template.workingDir);
+  const workingDir = resolve5(resolvePaneCwd(template, ctx), template.workingDir);
   return `cd -- ${quoteShell2(workingDir)} && ${template.command}`;
 }
 function resolvePaneStartupCommand(template, ctx) {
@@ -14329,7 +14918,7 @@ import { randomUUID } from "crypto";
 
 // backend/src/adapters/git.ts
 import { readdirSync, rmSync, statSync } from "fs";
-import { resolve as resolve5, join as join5 } from "path";
+import { resolve as resolve6, join as join5 } from "path";
 function runGit(args, cwd) {
   const result = Bun.spawnSync(["git", ...args], {
     cwd,
@@ -14363,8 +14952,8 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function isRegisteredWorktree(entries, worktreePath) {
-  const resolvedPath = resolve5(worktreePath);
-  return entries.some((entry) => resolve5(entry.path) === resolvedPath);
+  const resolvedPath = resolve6(worktreePath);
+  return entries.some((entry) => resolve6(entry.path) === resolvedPath);
 }
 function removeDirectory(path) {
   rmSync(path, {
@@ -14388,7 +14977,7 @@ function currentCheckoutRef(cwd) {
 function resolveRepoRoot(dir) {
   const direct = tryRunGit(["rev-parse", "--show-toplevel"], dir);
   if (direct.ok)
-    return resolve5(dir, direct.stdout);
+    return resolve6(dir, direct.stdout);
   let entries;
   try {
     entries = readdirSync(dir);
@@ -14405,17 +14994,17 @@ function resolveRepoRoot(dir) {
     }
     const childResult = tryRunGit(["rev-parse", "--show-toplevel"], child);
     if (childResult.ok)
-      return resolve5(child, childResult.stdout);
+      return resolve6(child, childResult.stdout);
   }
   return null;
 }
 function resolveWorktreeRoot(cwd) {
   const output = runGit(["rev-parse", "--show-toplevel"], cwd);
-  return resolve5(cwd, output);
+  return resolve6(cwd, output);
 }
 function resolveWorktreeGitDir(cwd) {
   const output = runGit(["rev-parse", "--git-dir"], cwd);
-  return resolve5(cwd, output);
+  return resolve6(cwd, output);
 }
 function parseGitWorktreePorcelain(output) {
   const entries = [];
@@ -14807,14 +15396,15 @@ function buildRuntimeControlBaseUrl(controlBaseUrl, runtime) {
 function prefixAgentBranch(agent, branch) {
   return `${agent}-${branch}`;
 }
-function buildCreateWorktreeTargets(branch, agentSelection) {
-  if (agentSelection === "both") {
-    return [
-      { branch: prefixAgentBranch("claude", branch), agent: "claude" },
-      { branch: prefixAgentBranch("codex", branch), agent: "codex" }
-    ];
+function buildCreateWorktreeTargets(branch, agentIds) {
+  if (agentIds.length <= 1) {
+    const agent = agentIds[0];
+    return agent ? [{ branch, agent }] : [];
   }
-  return [{ branch, agent: agentSelection }];
+  return agentIds.map((agent) => ({
+    branch: prefixAgentBranch(agent, branch),
+    agent
+  }));
 }
 
 class LifecycleError extends Error {
@@ -14832,12 +15422,12 @@ class LifecycleService {
   }
   async createWorktrees(input) {
     const mode = input.mode ?? "new";
-    const agentSelection = input.agent ?? this.deps.config.workspace.defaultAgent;
-    if (agentSelection === "both" && mode === "existing") {
-      throw new LifecycleError("Creating both agents is only supported for new worktrees", 400);
+    const agentIds = this.resolveSelectedAgents(input);
+    if (agentIds.length > 1 && mode === "existing") {
+      throw new LifecycleError("Creating multiple agents is only supported for new worktrees", 400);
     }
     const branch = await this.resolveBranch(input.branch, input.prompt, mode);
-    const targets = buildCreateWorktreeTargets(branch, agentSelection);
+    const targets = buildCreateWorktreeTargets(branch, agentIds);
     const createdBranches = [];
     try {
       for (const target of targets) {
@@ -14864,28 +15454,30 @@ class LifecycleService {
   async createWorktree(input) {
     const mode = input.mode ?? "new";
     const branch = await this.resolveBranch(input.branch, input.prompt, mode);
-    const agent = this.resolveAgent(input.agent);
+    const agent = this.resolveAgentDefinition(input.agent);
     return await this.createResolvedWorktree({
       ...input,
       mode,
       branch,
-      agent
+      agent: agent.id
     });
   }
   async openWorktree(branch) {
     try {
       const resolved = await this.resolveExistingWorktree(branch);
-      const launchMode = resolved.meta ? "resume" : "fresh";
       const initialized = resolved.meta ? await this.refreshManagedArtifacts(resolved) : await this.initializeUnmanagedWorktree(resolved);
-      const { profile } = this.resolveProfile(initialized.meta.profile);
+      const { profileName, profile } = this.resolveProfile(initialized.meta.profile);
+      const agent = this.resolveAgentDefinition(initialized.meta.agent);
+      const launchMode = resolved.meta && agent.capabilities.resume ? "resume" : "fresh";
       await ensureAgentRuntimeArtifacts({
         gitDir: initialized.paths.gitDir,
         worktreePath: resolved.entry.path
       });
       await this.materializeRuntimeSession({
         branch,
+        profileName,
         profile,
-        agent: initialized.meta.agent,
+        agent,
         initialized,
         worktreePath: resolved.entry.path,
         launchMode
@@ -15019,14 +15611,22 @@ class LifecycleService {
       profile
     };
   }
-  resolveAgent(agent) {
-    if (!agent)
-      return this.deps.config.workspace.defaultAgent;
-    if (agent !== "claude" && agent !== "codex") {
-      throw new LifecycleError(`Unknown agent: ${agent}`, 400);
+  resolveAgentDefinition(agentId) {
+    const resolvedAgentId = agentId ?? this.deps.config.workspace.defaultAgent;
+    const agent = getAgentDefinition(this.deps.config, resolvedAgentId);
+    if (!agent) {
+      throw new LifecycleError(`Unknown agent: ${resolvedAgentId}`, 400);
     }
     return agent;
   }
+  resolveSelectedAgents(input) {
+    const selectedAgents = input.agents && input.agents.length > 0 ? input.agents : [input.agent ?? this.deps.config.workspace.defaultAgent];
+    const dedupedAgentIds = [...new Set(selectedAgents.map((agent) => agent.trim()).filter((agent) => agent.length > 0))];
+    if (dedupedAgentIds.length === 0) {
+      throw new LifecycleError("At least one agent must be selected", 400);
+    }
+    return dedupedAgentIds.map((agentId) => this.resolveAgentDefinition(agentId).id);
+  }
   async buildStartupEnvValues(envOverrides) {
     const startupEnvValues = Object.fromEntries(Object.entries(this.deps.config.startupEnvs).map(([key, value]) => [key, stringifyStartupEnvValue(value)]));
     for (const [key, value] of Object.entries(envOverrides ?? {})) {
@@ -15042,20 +15642,20 @@ class LifecycleService {
     return allocateServicePorts(metas, this.deps.config.services);
   }
   resolveWorktreePath(branch) {
-    return resolve6(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
+    return resolve7(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
   }
   listLocalBranches() {
-    return this.deps.git.listLocalBranches(resolve6(this.deps.projectRoot));
+    return this.deps.git.listLocalBranches(resolve7(this.deps.projectRoot));
   }
   listRemoteBranches() {
-    return this.deps.git.listRemoteBranches(resolve6(this.deps.projectRoot));
+    return this.deps.git.listRemoteBranches(resolve7(this.deps.projectRoot));
   }
   listCheckedOutBranches() {
-    return new Set(this.deps.git.listWorktrees(resolve6(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
+    return new Set(this.deps.git.listWorktrees(resolve7(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
   }
   listProjectWorktrees() {
-    const projectRoot2 = resolve6(this.deps.projectRoot);
-    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve6(entry.path) !== projectRoot2);
+    const projectRoot2 = resolve7(this.deps.projectRoot);
+    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve7(entry.path) !== projectRoot2);
   }
   async readManagedMetas() {
     const metas = await Promise.all(this.listProjectWorktrees().map(async (entry) => {
@@ -15148,6 +15748,7 @@ class LifecycleService {
       });
       ensureSessionLayout(this.deps.tmux, this.buildSessionLayout({
         branch: input.branch,
+        profileName: input.profileName,
         profile: input.profile,
         agent: input.agent,
         initialized: input.initialized,
@@ -15160,6 +15761,7 @@ class LifecycleService {
     }
     ensureSessionLayout(this.deps.tmux, this.buildSessionLayout({
       branch: input.branch,
+      profileName: input.profileName,
       profile: input.profile,
       agent: input.agent,
       initialized: input.initialized,
@@ -15178,6 +15780,10 @@ class LifecycleService {
         agent: buildDockerAgentPaneCommand({
           agent: input.agent,
           runtimeEnvPath: input.initialized.paths.runtimeEnvPath,
+          repoRoot: this.deps.projectRoot,
+          worktreePath: input.worktreePath,
+          branch: input.branch,
+          profileName: input.profileName,
           yolo: input.profile.yolo === true,
           systemPrompt,
           prompt: input.launchMode === "fresh" ? input.prompt : undefined,
@@ -15188,6 +15794,10 @@ class LifecycleService {
         agent: buildAgentPaneCommand({
           agent: input.agent,
           runtimeEnvPath: input.initialized.paths.runtimeEnvPath,
+          repoRoot: this.deps.projectRoot,
+          worktreePath: input.worktreePath,
+          branch: input.branch,
+          profileName: input.profileName,
           yolo: input.profile.yolo === true,
           systemPrompt,
           prompt: input.launchMode === "fresh" ? input.prompt : undefined,
@@ -15312,6 +15922,7 @@ class LifecycleService {
     const baseBranch = input.mode === "new" ? requestedBaseBranch || this.deps.config.workspace.mainBranch : undefined;
     const branchAvailability = this.resolveBranchAvailability(input.branch, input.mode);
     const { profileName, profile } = this.resolveProfile(input.profile);
+    const agent = this.resolveAgentDefinition(input.agent);
     const worktreePath = this.resolveWorktreePath(input.branch);
     const createProgressBase = {
       branch: input.branch,
@@ -15336,7 +15947,7 @@ class LifecycleService {
         ...baseBranch ? { baseBranch } : {},
         ...branchAvailability.startPoint ? { startPoint: branchAvailability.startPoint } : {},
         profile: profileName,
-        agent: input.agent,
+        agent: agent.id,
         runtime: profile.runtime,
         startupEnvValues: await this.buildStartupEnvValues(input.envOverrides),
         allocatedPorts: await this.allocatePorts(),
@@ -15376,8 +15987,9 @@ class LifecycleService {
       });
       await this.materializeRuntimeSession({
         branch: input.branch,
+        profileName,
         profile,
-        agent: input.agent,
+        agent,
         initialized,
         worktreePath,
         prompt: input.prompt,
@@ -16114,7 +16726,7 @@ function mapCreationSnapshot(creating) {
     phase: creating.phase
   } : null;
 }
-function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue) {
+function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue, findAgentLabel) {
   return {
     branch: state.branch,
     ...state.baseBranch ? { baseBranch: state.baseBranch } : {},
@@ -16123,6 +16735,7 @@ function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue)
     archived: isArchived(state.path),
     profile: state.profile,
     agentName: state.agentName,
+    agentLabel: findAgentLabel ? findAgentLabel(state.agentName) : state.agentName,
     mux: state.session.exists,
     dirty: state.git.dirty,
     unpushed: state.git.aheadCount > 0,
@@ -16135,7 +16748,7 @@ function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue)
     creation: mapCreationSnapshot(creating)
   };
 }
-function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue) {
+function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue, findAgentLabel) {
   return {
     branch: creating.branch,
     ...creating.baseBranch ? { baseBranch: creating.baseBranch } : {},
@@ -16144,6 +16757,7 @@ function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue) {
     archived: isArchived(creating.path),
     profile: creating.profile,
     agentName: creating.agentName,
+    agentLabel: findAgentLabel ? findAgentLabel(creating.agentName) : creating.agentName,
     mux: false,
     dirty: false,
     unpushed: false,
@@ -16163,10 +16777,10 @@ function buildWorktreeSnapshots(input) {
   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, isArchived, input.findLinearIssue));
+  const worktrees = runtimeWorktrees.map((state) => mapWorktreeSnapshot(state, now, creatingByBranch.get(state.branch) ?? null, isArchived, input.findLinearIssue, input.findAgentLabel));
   for (const creating of creatingWorktrees) {
     if (!runtimeBranches.has(creating.branch)) {
-      worktrees.push(mapCreatingWorktreeSnapshot(creating, isArchived, input.findLinearIssue));
+      worktrees.push(mapCreatingWorktreeSnapshot(creating, isArchived, input.findLinearIssue, input.findAgentLabel));
     }
   }
   worktrees.sort((left, right) => left.branch.localeCompare(right.branch));
@@ -16195,6 +16809,7 @@ function buildAgentsUiWorktreeSummary(worktree, conversation) {
     archived: worktree.archived,
     profile: worktree.profile,
     agentName: worktree.agentName,
+    agentLabel: worktree.agentLabel,
     mux: worktree.mux,
     status: worktree.status,
     dirty: worktree.dirty,
@@ -16899,7 +17514,7 @@ class BunPortProbe {
     this.hostnames = hostnames;
   }
   isListening(port) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve8) => {
       let settled = false;
       let pending = this.hostnames.length;
       const settle = (result) => {
@@ -16908,20 +17523,20 @@ class BunPortProbe {
         if (result) {
           settled = true;
           clearTimeout(timer);
-          resolve7(true);
+          resolve8(true);
           return;
         }
         pending--;
         if (pending === 0) {
           settled = true;
           clearTimeout(timer);
-          resolve7(false);
+          resolve8(false);
         }
       };
       const timer = setTimeout(() => {
         if (!settled) {
           settled = true;
-          resolve7(false);
+          resolve8(false);
         }
       }, this.timeoutMs);
       for (const hostname of this.hostnames) {
@@ -16947,7 +17562,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 AUTO_NAME_TIMEOUT_MS = 15000;
 var DEFAULT_SYSTEM_PROMPT = [
   "Generate a concise git branch name from the task description.",
   "Return only the branch name.",
@@ -16999,7 +17614,7 @@ async function defaultSpawn(args, options = {}) {
   if (options.timeoutMs === undefined) {
     return await resultPromise;
   }
-  return await new Promise((resolve7, reject) => {
+  return await new Promise((resolve8, reject) => {
     let settled = false;
     const timeoutId = setTimeout(() => {
       if (settled)
@@ -17015,7 +17630,7 @@ async function defaultSpawn(args, options = {}) {
         return;
       settled = true;
       clearTimeout(timeoutId);
-      resolve7(result);
+      resolve8(result);
     }, (error) => {
       if (settled)
         return;
@@ -17153,8 +17768,8 @@ class ArchiveStateService {
   async withMutationLock(operation) {
     const previous = this.mutationQueue;
     let release = () => {};
-    this.mutationQueue = new Promise((resolve7) => {
-      release = resolve7;
+    this.mutationQueue = new Promise((resolve8) => {
+      release = resolve8;
     });
     await previous.catch(() => {});
     try {
@@ -17429,9 +18044,9 @@ class ProjectRuntime {
 }
 
 // backend/src/services/reconciliation-service.ts
-import { basename as basename3, resolve as resolve7 } from "path";
+import { basename as basename3, resolve as resolve8 } from "path";
 function makeUnmanagedWorktreeId(path) {
-  return `unmanaged:${resolve7(path)}`;
+  return `unmanaged:${resolve8(path)}`;
 }
 function isValidPort2(port) {
   return port !== null && Number.isInteger(port) && port >= 1 && port <= 65535;
@@ -17488,7 +18103,7 @@ class ReconciliationService {
     if (!options.force && this.now() - this.lastReconciledAt < this.freshnessMs) {
       return;
     }
-    const normalizedRepoRoot = resolve7(repoRoot);
+    const normalizedRepoRoot = resolve8(repoRoot);
     const reconcilePromise = this.runReconcile(normalizedRepoRoot).then(() => {
       this.lastReconciledAt = this.now();
     });
@@ -17507,7 +18122,7 @@ class ReconciliationService {
       windows = [];
     }
     const seenWorktreeIds = new Set;
-    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve7(entry.path) !== normalizedRepoRoot);
+    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve8(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);
@@ -17668,7 +18283,6 @@ function createWebmuxRuntime(options = {}) {
 // backend/src/server.ts
 var PORT = parseInt(Bun.env.PORT || "5111", 10);
 var STATIC_DIR = Bun.env.WEBMUX_STATIC_DIR || "";
-var CODEX_TMUX_PROMPT_SUBMIT_DELAY_MS = 200;
 var runtime = createWebmuxRuntime({
   port: PORT,
   projectDir: Bun.env.WEBMUX_PROJECT_DIR || process.cwd()
@@ -17741,13 +18355,15 @@ function getFrontendConfig() {
       name,
       ...profile.systemPrompt ? { systemPrompt: profile.systemPrompt } : {}
     })),
+    agents: listAgentSummaries(config),
     defaultProfileName,
+    defaultAgentId: config.workspace.defaultAgent,
     autoName: config.autoName !== null,
     linearCreateTicketOption: config.integrations.linear.enabled && config.integrations.linear.createTicketOption,
     startupEnvs: config.startupEnvs,
     linkedRepos: config.integrations.github.linkedRepos.map((lr) => ({
       alias: lr.alias,
-      ...lr.dir ? { dir: resolve8(PROJECT_DIR, lr.dir) } : {}
+      ...lr.dir ? { dir: resolve9(PROJECT_DIR, lr.dir) } : {}
     })),
     linearAutoCreateWorktrees: linearAutoCreateEnabled,
     autoRemoveOnMerge: autoRemoveOnMergeEnabled,
@@ -17851,7 +18467,8 @@ async function resolveTerminalWorktree(branch) {
     attachTarget: {
       ownerSessionName: state.session.sessionName,
       windowName: state.session.windowName
-    }
+    },
+    agentName: state.agentName
   };
 }
 async function resolveAgentsTerminalWorktree(branch) {
@@ -17899,9 +18516,9 @@ async function hasValidControlToken(req) {
 }
 async function getWorktreeGitDirs() {
   const gitDirs = new Map;
-  const projectRoot2 = resolve8(PROJECT_DIR);
+  const projectRoot2 = resolve9(PROJECT_DIR);
   for (const entry of git.listWorktrees(projectRoot2)) {
-    if (entry.bare || resolve8(entry.path) === projectRoot2 || !entry.branch)
+    if (entry.bare || resolve9(entry.path) === projectRoot2 || !entry.branch)
       continue;
     gitDirs.set(entry.branch, git.resolveWorktreeGitDir(entry.path));
   }
@@ -17941,6 +18558,11 @@ async function readProjectSnapshot() {
         url: match.url,
         state: match.state
       } : null;
+    },
+    findAgentLabel: (agentId) => {
+      if (!agentId)
+        return null;
+      return getAgentDefinition(config, agentId)?.label ?? agentId;
     }
   });
 }
@@ -17971,12 +18593,30 @@ async function resolveAgentsWorktree(branch) {
     worktree
   };
 }
+function resolveWorktreeAgentChatSupport(worktree, action) {
+  return resolveAgentChatSupport({
+    agentId: worktree.agentName,
+    agentLabel: worktree.agentLabel,
+    agent: worktree.agentName ? getAgentDefinition(config, worktree.agentName) : null,
+    action
+  });
+}
+function resolveWorktreeTerminalSubmitDelayMs(agentName) {
+  return resolveAgentTerminalSubmitDelayMs({
+    agentId: agentName,
+    agent: agentName ? getAgentDefinition(config, agentName) : null
+  });
+}
 async function apiAttachAgentsWorktree(branch) {
   touchDashboardActivity();
   const resolved = await resolveAgentsWorktree(branch);
   if (!resolved.ok)
     return resolved.response;
-  const result = resolved.worktree.agentName === "claude" ? await claudeConversationService.attachWorktreeConversation(resolved.worktree) : await worktreeConversationService.attachWorktreeConversation(resolved.worktree);
+  const chatSupport = resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  if (!chatSupport.ok) {
+    return errorResponse(chatSupport.error, chatSupport.status);
+  }
+  const result = chatSupport.data.provider === "claude" ? await claudeConversationService.attachWorktreeConversation(resolved.worktree) : await worktreeConversationService.attachWorktreeConversation(resolved.worktree);
   return result.ok ? jsonResponse(result.data) : errorResponse(result.error, result.status);
 }
 async function apiGetAgentsWorktreeHistory(branch) {
@@ -17984,7 +18624,11 @@ async function apiGetAgentsWorktreeHistory(branch) {
   const resolved = await resolveAgentsWorktree(branch);
   if (!resolved.ok)
     return resolved.response;
-  const result = resolved.worktree.agentName === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  const chatSupport = resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  if (!chatSupport.ok) {
+    return errorResponse(chatSupport.error, chatSupport.status);
+  }
+  const result = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
   return result.ok ? jsonResponse(result.data) : errorResponse(result.error, result.status);
 }
 async function apiSendAgentsWorktreeMessage(branch, req) {
@@ -17998,14 +18642,18 @@ async function apiSendAgentsWorktreeMessage(branch, req) {
   if (!resolved.worktree.mux) {
     return errorResponse("Open this worktree in the main dashboard before sending messages here", 409);
   }
-  const conversationResult = resolved.worktree.agentName === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  const chatSupport = resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  if (!chatSupport.ok) {
+    return errorResponse(chatSupport.error, chatSupport.status);
+  }
+  const conversationResult = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
   if (!conversationResult.ok) {
     return errorResponse(conversationResult.error, conversationResult.status);
   }
   const terminalWorktree = await resolveAgentsTerminalWorktree(branch);
   if (!terminalWorktree.ok)
     return terminalWorktree.response;
-  const sendResult = await sendPrompt(terminalWorktree.data.worktreeId, terminalWorktree.data.attachTarget, parsed.data.text, 0, undefined, resolved.worktree.agentName === "codex" ? CODEX_TMUX_PROMPT_SUBMIT_DELAY_MS : 0);
+  const sendResult = await sendPrompt(terminalWorktree.data.worktreeId, terminalWorktree.data.attachTarget, parsed.data.text, 0, undefined, chatSupport.data.submitDelayMs);
   if (!sendResult.ok) {
     return errorResponse(sendResult.error, 503);
   }
@@ -18023,7 +18671,11 @@ async function apiInterruptAgentsWorktree(branch) {
   if (!resolved.worktree.mux) {
     return errorResponse("Open this worktree in the main dashboard before interrupting it here", 409);
   }
-  const conversationResult = resolved.worktree.agentName === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  const chatSupport = resolveWorktreeAgentChatSupport(resolved.worktree, "interrupt");
+  if (!chatSupport.ok) {
+    return errorResponse(chatSupport.error, chatSupport.status);
+  }
+  const conversationResult = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
   if (!conversationResult.ok) {
     return errorResponse(conversationResult.error, conversationResult.status);
   }
@@ -18048,7 +18700,14 @@ async function loadAgentsConversationSnapshot(branch) {
       message: await readErrorMessage(resolved.response)
     };
   }
-  const result = resolved.worktree.agentName === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  const chatSupport = resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  if (!chatSupport.ok) {
+    return {
+      ok: false,
+      message: chatSupport.error
+    };
+  }
+  const result = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
   return result.ok ? { ok: true, data: result.data } : { ok: false, message: result.error };
 }
 async function readErrorMessage(response) {
@@ -18167,10 +18826,11 @@ async function apiCreateWorktree(req) {
   const prompt = body.prompt?.trim() ? body.prompt.trim() : undefined;
   const profile = body.profile;
   const agent = body.agent;
+  const agents = body.agents;
   const createLinearTicket = body.createLinearTicket === true;
   const linearTitle = body.linearTitle?.trim() ? body.linearTitle.trim() : undefined;
   const mode = body.mode;
-  const agentSelection = agent ?? config.workspace.defaultAgent;
+  const selectedAgents = agents ? agents : agent ? [agent] : [config.workspace.defaultAgent];
   if (baseBranch && !isValidBranchName(baseBranch)) {
     return errorResponse("Invalid base branch name", 400);
   }
@@ -18211,7 +18871,7 @@ async function apiCreateWorktree(req) {
     log.info(`[linear] created ticket ${linearResult.data.identifier} branch=${linearResult.data.branchName} title="${linearResult.data.title.slice(0, 80)}"`);
   }
   if (resolvedBranch) {
-    const targetBranches = buildCreateWorktreeTargets(resolvedBranch, agentSelection).map((target) => target.branch);
+    const targetBranches = buildCreateWorktreeTargets(resolvedBranch, selectedAgents).map((target) => target.branch);
     for (const targetBranch of targetBranches) {
       ensureBranchNotBusy(targetBranch);
     }
@@ -18219,14 +18879,14 @@ async function apiCreateWorktree(req) {
       return errorResponse("Base branch must differ from branch name", 400);
     }
   }
-  log.info(`[worktree:add] mode=${mode ?? "new"}${resolvedBranch ? ` branch=${resolvedBranch}` : ""}${baseBranch ? ` base=${baseBranch}` : ""}${profile ? ` profile=${profile}` : ""} agent=${agentSelection}${createLinearTicket ? " linearTicket=true" : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
+  log.info(`[worktree:add] mode=${mode ?? "new"}${resolvedBranch ? ` branch=${resolvedBranch}` : ""}${baseBranch ? ` base=${baseBranch}` : ""}${profile ? ` profile=${profile}` : ""} agents=${selectedAgents.join(",")}${createLinearTicket ? " linearTicket=true" : ""}${prompt ? ` prompt="${prompt.slice(0, 80)}"` : ""}`);
   const result = await lifecycleService.createWorktrees({
     mode,
     branch: resolvedBranch,
     baseBranch,
     prompt,
     profile,
-    agent: agentSelection,
+    ...agents && agents.length > 0 ? { agents } : { agent },
     envOverrides
   });
   log.debug(`[worktree:add] done branches=${result.branches.join(",")}`);
@@ -18278,7 +18938,8 @@ async function apiSendPrompt(name, req) {
   const preamble = body.preamble;
   log.info(`[worktree:send] name=${name} text="${text.slice(0, 80)}"`);
   const terminalWorktree = await resolveTerminalWorktree(name);
-  const result = await sendPrompt(terminalWorktree.worktreeId, terminalWorktree.attachTarget, text, 0, preamble);
+  const submitDelayMs = resolveWorktreeTerminalSubmitDelayMs(terminalWorktree.agentName);
+  const result = await sendPrompt(terminalWorktree.worktreeId, terminalWorktree.attachTarget, text, 0, preamble, submitDelayMs);
   if (!result.ok)
     return errorResponse(result.error, 503);
   return jsonResponse({ ok: true });
@@ -18290,6 +18951,72 @@ async function apiMergeWorktree(name) {
   log.debug(`[worktree:merge] done name=${name}`);
   return jsonResponse({ ok: true });
 }
+async function apiListAgents() {
+  return jsonResponse({ agents: listAgentDetails(config) });
+}
+async function apiValidateAgent(req) {
+  const parsed = await parseJsonBody(req, UpsertCustomAgentRequestSchema);
+  if (!parsed.ok)
+    return parsed.response;
+  return jsonResponse(validateCustomAgentInput(parsed.data));
+}
+async function apiCreateAgent(req) {
+  const parsed = await parseJsonBody(req, UpsertCustomAgentRequestSchema);
+  if (!parsed.ok)
+    return parsed.response;
+  const body = parsed.data;
+  const agentId = normalizeCustomAgentId(body.label);
+  if (isBuiltInAgentId(agentId) || config.agents[agentId]) {
+    return errorResponse(`Agent already exists: ${agentId}`, 409);
+  }
+  const agentConfig = {
+    label: body.label,
+    startCommand: body.startCommand,
+    ...body.resumeCommand?.trim() ? { resumeCommand: body.resumeCommand.trim() } : {}
+  };
+  await persistLocalCustomAgent(PROJECT_DIR, agentId, agentConfig);
+  config.agents[agentId] = agentConfig;
+  const agent = listAgentDetails(config).find((entry) => entry.id === agentId);
+  if (!agent) {
+    return errorResponse(`Created agent could not be loaded: ${agentId}`, 500);
+  }
+  return jsonResponse({ agent });
+}
+async function apiUpdateAgent(agentId, req) {
+  if (isBuiltInAgentId(agentId)) {
+    return errorResponse(`Built-in agent cannot be edited: ${agentId}`, 400);
+  }
+  if (!config.agents[agentId]) {
+    return errorResponse(`Unknown agent: ${agentId}`, 404);
+  }
+  const parsed = await parseJsonBody(req, UpsertCustomAgentRequestSchema);
+  if (!parsed.ok)
+    return parsed.response;
+  const body = parsed.data;
+  const agentConfig = {
+    label: body.label,
+    startCommand: body.startCommand,
+    ...body.resumeCommand?.trim() ? { resumeCommand: body.resumeCommand.trim() } : {}
+  };
+  await persistLocalCustomAgent(PROJECT_DIR, agentId, agentConfig);
+  config.agents[agentId] = agentConfig;
+  const agent = listAgentDetails(config).find((entry) => entry.id === agentId);
+  if (!agent) {
+    return errorResponse(`Updated agent could not be loaded: ${agentId}`, 500);
+  }
+  return jsonResponse({ agent });
+}
+async function apiDeleteAgent(agentId) {
+  if (isBuiltInAgentId(agentId)) {
+    return errorResponse(`Built-in agent cannot be deleted: ${agentId}`, 400);
+  }
+  if (!config.agents[agentId]) {
+    return errorResponse(`Unknown agent: ${agentId}`, 404);
+  }
+  await removeLocalCustomAgent(PROJECT_DIR, agentId);
+  delete config.agents[agentId];
+  return jsonResponse({ ok: true });
+}
 async function apiSetLinearAutoCreate(req) {
   const parsed = await parseJsonBody(req, ToggleEnabledRequestSchema);
   if (!parsed.ok)
@@ -18332,7 +19059,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 = resolve8(PROJECT_DIR, linkedRepo.dir);
+    const resolvedDir = resolve9(PROJECT_DIR, linkedRepo.dir);
     const repoRoot = git.resolveRepoRoot(resolvedDir);
     if (!repoRoot)
       return errorResponse(`Linked repo "${repo}" dir is not a git repository: ${resolvedDir}`, 400);
@@ -18423,7 +19150,7 @@ async function apiUploadFiles(name, req) {
     }
     const safeName = `${Date.now()}_${sanitizeFilename(entry.name)}`;
     const destPath = join8(uploadDir, safeName);
-    if (!resolve8(destPath).startsWith(uploadDir + "/")) {
+    if (!resolve9(destPath).startsWith(uploadDir + "/")) {
       return errorResponse("Invalid filename", 400);
     }
     await Bun.write(destPath, entry);
@@ -18465,6 +19192,22 @@ function parseNotificationIdParam(params) {
     data: parsed.data.id
   };
 }
+function parseAgentIdParam(params) {
+  const parsed = parseParams(params, AgentIdParamsSchema);
+  if (!parsed.ok)
+    return parsed;
+  const agentId = parsed.data.id.trim();
+  if (!agentId) {
+    return {
+      ok: false,
+      response: errorResponse("Invalid agent id", 400)
+    };
+  }
+  return {
+    ok: true,
+    data: agentId
+  };
+}
 Bun.serve({
   port: PORT,
   idleTimeout: 255,
@@ -18491,6 +19234,27 @@ Bun.serve({
     [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);
@@ -18655,8 +19419,8 @@ Bun.serve({
     if (STATIC_DIR) {
       const rawPath = url.pathname === "/" ? "index.html" : url.pathname;
       const filePath = join8(STATIC_DIR, rawPath);
-      const staticRoot = resolve8(STATIC_DIR);
-      if (!resolve8(filePath).startsWith(staticRoot + "/")) {
+      const staticRoot = resolve9(STATIC_DIR);
+      if (!resolve9(filePath).startsWith(staticRoot + "/")) {
         return new Response("Forbidden", { status: 403 });
       }
       const file = Bun.file(filePath);