webmux 0.28.1 → 0.30.0

package/bin/webmux.js

@@ -7190,7 +7190,7 @@ var init_index_esm = __esm(() => {
 });
 
 // packages/api-contract/src/schemas.ts
-var BooleanLikeSchema, ErrorResponseSchema, OkResponseSchema, EnabledResponseSchema, AgentKindSchema, CreateWorktreeAgentSelectionSchema, WorktreeCreateModeSchema, WorktreeCreationPhaseSchema, AvailableBranchSchema, AvailableBranchesQuerySchema, NumberLikePathParamSchema, BranchListResponseSchema, CreateWorktreeRequestSchema, CreateWorktreeResponseSchema, SetWorktreeArchivedRequestSchema, SetWorktreeArchivedResponseSchema, ToggleEnabledRequestSchema, SendWorktreePromptRequestSchema, AgentsSendMessageRequestSchema, PullMainRequestSchema, PullMainStatusSchema, PullMainResponseSchema, ServiceStatusSchema, PrCommentSchema, CiCheckSchema, PrEntrySchema, LinearIssueLabelSchema, LinearIssueStateSchema, LinkedLinearIssueSchema, LinearIssueSchema, LinearIssueAvailabilitySchema, LinearIssuesResponseSchema, WorktreeCreationStateSchema, AppNotificationSchema, ProjectWorktreeSnapshotSchema, ProjectSnapshotSchema, WorktreeConversationProviderSchema, CodexWorktreeConversationRefSchema, ClaudeWorktreeConversationRefSchema, WorktreeConversationRefSchema, AgentsUiWorktreeSummarySchema, AgentsUiConversationMessageRoleSchema, AgentsUiConversationMessageStatusSchema, AgentsUiConversationMessageSchema, AgentsUiConversationStateSchema, AgentsUiWorktreeConversationResponseSchema, AgentsUiSendMessageResponseSchema, AgentsUiInterruptResponseSchema, AgentsUiConversationSnapshotEventSchema, AgentsUiConversationMessageDeltaEventSchema, AgentsUiConversationErrorEventSchema, AgentsUiConversationEventSchema, WorktreeListResponseSchema, UnpushedCommitSchema, WorktreeDiffResponseSchema, ServiceConfigSchema, ProfileConfigSchema, LinkedRepoInfoSchema, AppConfigSchema, CiLogsResponseSchema, WorktreeNameParamsSchema, NotificationIdParamsSchema, RunIdParamsSchema;
+var BooleanLikeSchema, ErrorResponseSchema, OkResponseSchema, EnabledResponseSchema, BuiltInAgentIdSchema, AgentIdSchema, WorktreeCreateModeSchema, AgentCapabilitiesSchema, AgentSummarySchema, AgentDetailsSchema, AgentListResponseSchema, UpsertCustomAgentRequestSchema, AgentResponseSchema, ValidateCustomAgentResponseSchema, WorktreeCreationPhaseSchema, AvailableBranchSchema, AvailableBranchesQuerySchema, NumberLikePathParamSchema, BranchListResponseSchema, CreateWorktreeRequestSchema, CreateWorktreeResponseSchema, SetWorktreeArchivedRequestSchema, SetWorktreeArchivedResponseSchema, ToggleEnabledRequestSchema, SendWorktreePromptRequestSchema, AgentsSendMessageRequestSchema, PullMainRequestSchema, PullMainStatusSchema, PullMainResponseSchema, ServiceStatusSchema, PrCommentSchema, CiCheckSchema, PrEntrySchema, LinearIssueLabelSchema, LinearIssueStateSchema, LinkedLinearIssueSchema, LinearIssueSchema, LinearIssueAvailabilitySchema, LinearIssuesResponseSchema, WorktreeCreationStateSchema, AppNotificationSchema, ProjectWorktreeSnapshotSchema, ProjectSnapshotSchema, WorktreeConversationProviderSchema, CodexWorktreeConversationRefSchema, ClaudeWorktreeConversationRefSchema, WorktreeConversationRefSchema, AgentsUiWorktreeSummarySchema, AgentsUiConversationMessageRoleSchema, AgentsUiConversationMessageStatusSchema, AgentsUiConversationMessageSchema, AgentsUiConversationStateSchema, AgentsUiWorktreeConversationResponseSchema, AgentsUiSendMessageResponseSchema, AgentsUiInterruptResponseSchema, AgentsUiConversationSnapshotEventSchema, AgentsUiConversationMessageDeltaEventSchema, AgentsUiConversationErrorEventSchema, AgentsUiConversationEventSchema, WorktreeListResponseSchema, UnpushedCommitSchema, WorktreeDiffResponseSchema, ServiceConfigSchema, ProfileConfigSchema, LinkedRepoInfoSchema, AppConfigSchema, CiLogsResponseSchema, WorktreeNameParamsSchema, NotificationIdParamsSchema, AgentIdParamsSchema, RunIdParamsSchema;
 var init_schemas = __esm(() => {
   init_zod();
   BooleanLikeSchema = exports_external.union([
@@ -7208,9 +7208,45 @@ var init_schemas = __esm(() => {
     ok: exports_external.literal(true),
     enabled: exports_external.boolean()
   });
-  AgentKindSchema = exports_external.enum(["claude", "codex"]);
-  CreateWorktreeAgentSelectionSchema = exports_external.enum(["claude", "codex", "both"]);
+  BuiltInAgentIdSchema = exports_external.enum(["claude", "codex"]);
+  AgentIdSchema = exports_external.string().trim().min(1);
   WorktreeCreateModeSchema = exports_external.enum(["new", "existing"]);
+  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()
+  });
+  AgentSummarySchema = exports_external.object({
+    id: AgentIdSchema,
+    label: exports_external.string(),
+    kind: exports_external.enum(["builtin", "custom"]),
+    capabilities: AgentCapabilitiesSchema
+  });
+  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()
+  });
+  AgentListResponseSchema = exports_external.object({
+    agents: exports_external.array(AgentDetailsSchema)
+  });
+  UpsertCustomAgentRequestSchema = exports_external.object({
+    label: exports_external.string().trim().min(1),
+    startCommand: exports_external.string().trim().min(1),
+    resumeCommand: exports_external.string().trim().optional()
+  });
+  AgentResponseSchema = exports_external.object({
+    agent: AgentDetailsSchema
+  });
+  ValidateCustomAgentResponseSchema = exports_external.object({
+    normalizedId: AgentIdSchema,
+    warnings: exports_external.array(exports_external.string())
+  });
   WorktreeCreationPhaseSchema = exports_external.enum([
     "creating_worktree",
     "preparing_runtime",
@@ -7236,7 +7272,8 @@ var init_schemas = __esm(() => {
     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(),
@@ -7367,7 +7404,8 @@ var init_schemas = __esm(() => {
     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(),
@@ -7412,7 +7450,8 @@ var init_schemas = __esm(() => {
     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(),
@@ -7504,7 +7543,9 @@ var init_schemas = __esm(() => {
     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()])),
@@ -7523,6 +7564,9 @@ var init_schemas = __esm(() => {
   NotificationIdParamsSchema = exports_external.object({
     id: NumberLikePathParamSchema
   });
+  AgentIdParamsSchema = exports_external.object({
+    id: AgentIdSchema
+  });
   RunIdParamsSchema = exports_external.object({
     runId: NumberLikePathParamSchema
   });
@@ -7539,6 +7583,11 @@ var init_contract = __esm(() => {
     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",
@@ -7603,6 +7652,60 @@ var init_contract = __esm(() => {
         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: c2.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,
@@ -15342,6 +15445,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 (!isRecord4(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 (!isRecord4(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 [];
@@ -15434,6 +15569,7 @@ function parseProjectConfig(parsed) {
       autoPull: isRecord4(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: {
@@ -15501,20 +15637,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 = isRecord4(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) {
@@ -15574,6 +15711,10 @@ function loadConfig(dir, options = {}) {
       ...cloneProfiles(projectConfig.profiles),
       ...cloneProfiles(localOverlay.profiles)
     },
+    agents: {
+      ...cloneAgents(projectConfig.agents),
+      ...cloneAgents(localOverlay.agents)
+    },
     lifecycleHooks: mergeLifecycleHooks(projectConfig.lifecycleHooks, localOverlay.lifecycleHooks),
     integrations
   };
@@ -15603,6 +15744,7 @@ var init_config = __esm(() => {
         panes: clonePanes(DEFAULT_PANES)
       }
     },
+    agents: {},
     services: [],
     startupEnvs: {},
     integrations: {
@@ -16184,7 +16326,7 @@ class AutoNameService {
     return normalizeGeneratedBranchName(output);
   }
 }
-var MAX_BRANCH_LENGTH = 40, DEFAULT_AUTO_NAME_MODEL = "claude-haiku-4-5-20251001", AUTO_NAME_TIMEOUT_MS = 1e4, DEFAULT_SYSTEM_PROMPT, AutoNameTimeoutError;
+var MAX_BRANCH_LENGTH = 40, DEFAULT_AUTO_NAME_MODEL = "claude-haiku-4-5-20251001", AUTO_NAME_TIMEOUT_MS = 15000, DEFAULT_SYSTEM_PROMPT, AutoNameTimeoutError;
 var init_auto_name_service = __esm(() => {
   init_policies();
   init_branch_name();
@@ -16271,7 +16413,7 @@ var init_archive_state_service = __esm(() => {
 
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname4, join as join9 } from "path";
+import { dirname as dirname4, join as join9, resolve as resolve6 } from "path";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -16290,6 +16432,7 @@ from pathlib import Path
 
 
 CONTROL_ENV_PATH = Path(__file__).resolve().with_name("control.env")
+CONTROL_REQUEST_TIMEOUT_SECONDS = 2
 
 
 def read_control_env():
@@ -16319,6 +16462,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")
@@ -16328,6 +16472,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
 
@@ -16370,6 +16519,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"],
@@ -16382,7 +16566,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
@@ -16416,34 +16600,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
 
@@ -16513,6 +16703,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 {
@@ -16532,13 +16797,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(join9(gitDir, "commondir")).text()).trim();
+    if (!commonDir)
+      return gitDir;
+    return commonDir.startsWith("/") ? commonDir : resolve6(gitDir, commonDir);
+  } catch {
+    return gitDir;
+  }
+}
+async function ensureGeneratedCodexHooksIgnored(gitDir) {
+  const commonDir = await resolveGitCommonDir(gitDir);
+  const excludePath = join9(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(dirname4(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: join9(storagePaths.webmuxDir, "webmux-agentctl"),
-    claudeSettingsPath: join9(input.worktreePath, ".claude", "settings.local.json")
+    claudeSettingsPath: join9(input.worktreePath, ".claude", "settings.local.json"),
+    codexHooksPath: join9(input.worktreePath, ".codex", "hooks.json")
   };
   await mkdir3(dirname4(artifacts.claudeSettingsPath), { recursive: true });
+  await mkdir3(dirname4(artifacts.codexHooksPath), { recursive: true });
   await Bun.write(artifacts.agentCtlPath, buildAgentCtlScript());
   await chmod2(artifacts.agentCtlPath, 493);
   const hookSettings = buildClaudeHookSettings(artifacts);
@@ -16547,8 +16876,11 @@ 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;
 }
+var GENERATED_CODEX_HOOKS_EXCLUDE = ".codex/hooks.json";
 var init_agent_runtime = __esm(() => {
   init_fs();
 });
@@ -16563,17 +16895,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") {
@@ -16585,6 +16918,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)}`;
 }
@@ -16603,10 +16977,112 @@ function buildDockerShellCommand(containerName2, worktreePath, runtimeEnvPath, s
 function buildDockerAgentPaneCommand(input) {
   return buildAgentCommand(input, buildDockerRuntimeBootstrap);
 }
-var DOCKER_PATH_FALLBACK = "/root/.local/bin:/usr/local/bin:/root/.bun/bin:/root/.cargo/bin";
+var DOCKER_PATH_FALLBACK = "/root/.local/bin:/usr/local/bin:/root/.bun/bin:/root/.cargo/bin", CUSTOM_AGENT_TEMPLATE_VARS;
+var init_agent_service = __esm(() => {
+  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"
+  };
+});
+
+// backend/src/services/agent-registry.ts
+function cloneCapabilities(capabilities) {
+  return { ...capabilities };
+}
+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;
+}
+var BUILTIN_AGENT_DEFINITIONS;
+var init_agent_registry = __esm(() => {
+  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"
+      }
+    }
+  ];
+});
 
 // backend/src/services/session-service.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 function quoteShell2(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -16620,7 +17096,7 @@ function buildCommandPaneStartupCommand(template, ctx) {
   if (!template.workingDir) {
     return template.command;
   }
-  const workingDir = resolve6(resolvePaneCwd(template, ctx), template.workingDir);
+  const workingDir = resolve7(resolvePaneCwd(template, ctx), template.workingDir);
   return `cd -- ${quoteShell2(workingDir)} && ${template.command}`;
 }
 function resolvePaneStartupCommand(template, ctx) {
@@ -16850,7 +17326,7 @@ var init_worktree_service = __esm(() => {
 
 // backend/src/services/lifecycle-service.ts
 import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname5, resolve as resolve7 } from "path";
+import { dirname as dirname5, resolve as resolve8 } from "path";
 function toErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -16880,14 +17356,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 LifecycleService {
@@ -16897,12 +17374,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) {
@@ -16929,28 +17406,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
@@ -17084,14 +17563,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 ?? {})) {
@@ -17107,20 +17594,20 @@ class LifecycleService {
     return allocateServicePorts(metas, this.deps.config.services);
   }
   resolveWorktreePath(branch) {
-    return resolve7(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
+    return resolve8(this.deps.projectRoot, this.deps.config.workspace.worktreeRoot, branch);
   }
   listLocalBranches() {
-    return this.deps.git.listLocalBranches(resolve7(this.deps.projectRoot));
+    return this.deps.git.listLocalBranches(resolve8(this.deps.projectRoot));
   }
   listRemoteBranches() {
-    return this.deps.git.listRemoteBranches(resolve7(this.deps.projectRoot));
+    return this.deps.git.listRemoteBranches(resolve8(this.deps.projectRoot));
   }
   listCheckedOutBranches() {
-    return new Set(this.deps.git.listWorktrees(resolve7(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
+    return new Set(this.deps.git.listWorktrees(resolve8(this.deps.projectRoot)).filter((entry) => !entry.bare && entry.branch !== null).map((entry) => entry.branch));
   }
   listProjectWorktrees() {
-    const projectRoot2 = resolve7(this.deps.projectRoot);
-    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve7(entry.path) !== projectRoot2);
+    const projectRoot2 = resolve8(this.deps.projectRoot);
+    return this.deps.git.listWorktrees(projectRoot2).filter((entry) => !entry.bare && resolve8(entry.path) !== projectRoot2);
   }
   async readManagedMetas() {
     const metas = await Promise.all(this.listProjectWorktrees().map(async (entry) => {
@@ -17213,6 +17700,7 @@ class LifecycleService {
       });
       ensureSessionLayout(this.deps.tmux, this.buildSessionLayout({
         branch: input.branch,
+        profileName: input.profileName,
         profile: input.profile,
         agent: input.agent,
         initialized: input.initialized,
@@ -17225,6 +17713,7 @@ class LifecycleService {
     }
     ensureSessionLayout(this.deps.tmux, this.buildSessionLayout({
       branch: input.branch,
+      profileName: input.profileName,
       profile: input.profile,
       agent: input.agent,
       initialized: input.initialized,
@@ -17243,6 +17732,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,
@@ -17253,6 +17746,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,
@@ -17377,6 +17874,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,
@@ -17401,7 +17899,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(),
@@ -17441,8 +17939,9 @@ class LifecycleService {
       });
       await this.materializeRuntimeSession({
         branch: input.branch,
+        profileName,
         profile,
-        agent: input.agent,
+        agent,
         initialized,
         worktreePath,
         prompt: input.prompt,
@@ -17483,6 +17982,8 @@ var init_lifecycle_service = __esm(() => {
   init_config();
   init_tmux();
   init_policies();
+  init_agent_service();
+  init_agent_registry();
   init_session_service();
   init_worktree_service();
   init_log();
@@ -17778,9 +18279,9 @@ async function mapWithConcurrency(items, limit, fn) {
 }
 
 // backend/src/services/reconciliation-service.ts
-import { basename as basename4, resolve as resolve8 } from "path";
+import { basename as basename4, resolve as resolve9 } from "path";
 function makeUnmanagedWorktreeId(path) {
-  return `unmanaged:${resolve8(path)}`;
+  return `unmanaged:${resolve9(path)}`;
 }
 function isValidPort2(port) {
   return port !== null && Number.isInteger(port) && port >= 1 && port <= 65535;
@@ -17837,7 +18338,7 @@ class ReconciliationService {
     if (!options.force && this.now() - this.lastReconciledAt < this.freshnessMs) {
       return;
     }
-    const normalizedRepoRoot = resolve8(repoRoot);
+    const normalizedRepoRoot = resolve9(repoRoot);
     const reconcilePromise = this.runReconcile(normalizedRepoRoot).then(() => {
       this.lastReconciledAt = this.now();
     });
@@ -17856,7 +18357,7 @@ class ReconciliationService {
       windows = [];
     }
     const seenWorktreeIds = new Set;
-    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve8(entry.path) !== normalizedRepoRoot);
+    const candidateEntries = worktrees.filter((entry) => !entry.bare && resolve9(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);
@@ -18042,19 +18543,19 @@ __export(exports_worktree_commands, {
   parseAddCommandArgs: () => parseAddCommandArgs,
   getWorktreeCommandUsage: () => getWorktreeCommandUsage
 });
-import { basename as basename5, resolve as resolve9 } from "path";
+import { basename as basename5, resolve as resolve10 } from "path";
 function getWorktreeCommandUsage(command) {
   switch (command) {
     case "add":
       return [
         "Usage:",
-        "  webmux add [branch] [--existing] [--base <branch>] [--profile <name>] [--agent <claude|codex|both>] [--prompt <text>] [--env KEY=VALUE] [--detach]",
+        "  webmux add [branch] [--existing] [--base <branch>] [--profile <name>] [--agent <id>] [--prompt <text>] [--env KEY=VALUE] [--detach]",
         "",
         "Options:",
         "  --existing               Use an existing local or remote branch instead of creating a new one",
         "  --base <branch>         Base branch for a new worktree (defaults to config)",
         "  --profile <name>         Worktree profile from .webmux.yaml",
-        "  --agent <claude|codex|both> Agent to launch (both creates paired worktrees)",
+        "  --agent <id>              Agent id to launch (repeatable)",
         "  --prompt <text>          Initial agent prompt",
         "  --env KEY=VALUE          Runtime env override (repeatable)",
         "  -d, --detach             Create worktree without switching to it",
@@ -18129,14 +18630,16 @@ function readOptionValue(args, index, flag) {
   };
 }
 function parseAgent(value) {
-  if (value === "claude" || value === "codex" || value === "both") {
-    return value;
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new CommandUsageError("Agent id cannot be empty");
   }
-  throw new CommandUsageError(`Unknown agent: ${value}`);
+  return trimmed;
 }
 function parseAddCommandArgs(args) {
   const input = {};
   const envOverrides = {};
+  const selectedAgents = [];
   let detach = false;
   for (let index = 0;index < args.length; index++) {
     const arg = args[index];
@@ -18167,7 +18670,7 @@ function parseAddCommandArgs(args) {
     }
     if (arg === "--agent" || arg.startsWith("--agent=")) {
       const { value, nextIndex } = readOptionValue(args, index, "--agent");
-      input.agent = parseAgent(value);
+      selectedAgents.push(parseAgent(value));
       index = nextIndex;
       continue;
     }
@@ -18195,6 +18698,9 @@ function parseAddCommandArgs(args) {
     }
     input.branch = arg;
   }
+  if (selectedAgents.length > 0) {
+    input.agents = selectedAgents;
+  }
   if (Object.keys(envOverrides).length > 0) {
     input.envOverrides = envOverrides;
   }
@@ -18318,8 +18824,8 @@ function parseListCommandArgs(args) {
   return { mode, search };
 }
 function listProjectWorktrees(runtime) {
-  const projectDir = resolve9(runtime.projectDir);
-  return runtime.git.listWorktrees(projectDir).filter((entry) => !entry.bare && resolve9(entry.path) !== projectDir);
+  const projectDir = resolve10(runtime.projectDir);
+  return runtime.git.listWorktrees(projectDir).filter((entry) => !entry.bare && resolve10(entry.path) !== projectDir);
 }
 async function defaultConfirmPrune(worktreeCount) {
   const response = await ot2({
@@ -18329,7 +18835,7 @@ async function defaultConfirmPrune(worktreeCount) {
   return !q(response) && response;
 }
 function defaultSwitchToTmuxWindow(projectDir, branch) {
-  const sessionName = buildProjectSessionName(resolve9(projectDir));
+  const sessionName = buildProjectSessionName(resolve10(projectDir));
   const windowName = buildWorktreeWindowName(branch);
   const target = `${sessionName}:${windowName}`;
   const selectResult = Bun.spawnSync(["tmux", "select-window", "-t", target], {
@@ -18361,7 +18867,7 @@ function matchesListSearch(row, query) {
   return query.length === 0 || row.searchText.toLowerCase().includes(query.toLowerCase());
 }
 async function listWorktrees(runtime, stdout, options) {
-  const projectDir = resolve9(runtime.projectDir);
+  const projectDir = resolve10(runtime.projectDir);
   const entries = listProjectWorktrees(runtime);
   if (entries.length === 0) {
     stdout("No worktrees found.");
@@ -18386,7 +18892,7 @@ async function listWorktrees(runtime, stdout, options) {
     return {
       branch,
       isOpen,
-      archived: archivedPaths.has(resolve9(entry.path)),
+      archived: archivedPaths.has(resolve10(entry.path)),
       info,
       searchText: [
         branch,
@@ -18452,21 +18958,12 @@ async function runWorktreeCommand(context, deps2 = {}) {
       if (!parsed.input.branch && parsed.input.prompt && runtime2.config.autoName) {
         stdout("Generating branch name...");
       }
-      if (parsed.input.agent === "both") {
-        const result = await runtime2.lifecycleService.createWorktrees(parsed.input);
-        for (const branch2 of result.branches) {
-          stdout(`Created worktree ${branch2}`);
-        }
-        if (!parsed.detach) {
-          switchToTmuxWindow(runtime2.projectDir, result.primaryBranch);
-        }
-      } else {
-        const { agent, ...rest } = parsed.input;
-        const result = await runtime2.lifecycleService.createWorktree({ ...rest, agent });
-        stdout(`Created worktree ${result.branch}`);
-        if (!parsed.detach) {
-          switchToTmuxWindow(runtime2.projectDir, result.branch);
-        }
+      const result = await runtime2.lifecycleService.createWorktrees(parsed.input);
+      for (const branch2 of result.branches) {
+        stdout(`Created worktree ${branch2}`);
+      }
+      if (!parsed.detach) {
+        switchToTmuxWindow(runtime2.projectDir, result.primaryBranch);
       }
       return 0;
     }
@@ -18599,13 +19096,13 @@ var init_worktree_commands = __esm(() => {
 });
 
 // bin/src/webmux.ts
-import { resolve as resolve10, dirname as dirname6, join as join11 } from "path";
+import { resolve as resolve11, dirname as dirname6, join as join11 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.28.1",
+  version: "0.30.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -18629,9 +19126,7 @@ var package_default = {
     "frontend",
     "packages/*"
   ],
-  dependencies: {
-    "@webmux/api-contract": "workspace:*"
-  },
+  dependencies: {},
   scripts: {
     dev: "bash dev.sh",
     start: "bun bin/webmux.js",
@@ -18646,6 +19141,7 @@ var package_default = {
     "frontend/dist/"
   ],
   devDependencies: {
+    "@webmux/api-contract": "workspace:*",
     "@clack/prompts": "^1.1.0",
     "@sveltejs/vite-plugin-svelte": "^5.0.0",
     "@tailwindcss/vite": "^4.2.0",
@@ -18663,7 +19159,7 @@ var package_default = {
 };
 
 // bin/src/webmux.ts
-var PKG_ROOT = resolve10(dirname6(fileURLToPath(import.meta.url)), "..");
+var PKG_ROOT = resolve11(dirname6(fileURLToPath(import.meta.url)), "..");
 function usage2() {
   console.log(`
 webmux \u2014 Dev dashboard for managing Git worktrees
@@ -18878,8 +19374,8 @@ async function main(args = process.argv.slice(2)) {
     const code = await proc.exited;
     process.exit(code);
   }
-  await loadEnvFile(resolve10(process.cwd(), ".env.local"));
-  await loadEnvFile(resolve10(process.cwd(), ".env"));
+  await loadEnvFile(resolve11(process.cwd(), ".env.local"));
+  await loadEnvFile(resolve11(process.cwd(), ".env"));
   if (isWorktreeCommand(parsed.command)) {
     const { runWorktreeCommand: runWorktreeCommand2 } = await Promise.resolve().then(() => (init_worktree_commands(), exports_worktree_commands));
     const exitCode2 = await runWorktreeCommand2({
@@ -18894,7 +19390,7 @@ async function main(args = process.argv.slice(2)) {
     usage2();
     process.exit(0);
   }
-  if (!existsSync5(resolve10(process.cwd(), ".webmux.yaml"))) {
+  if (!existsSync5(resolve11(process.cwd(), ".webmux.yaml"))) {
     console.error("No .webmux.yaml found in this directory.\nRun `webmux init` to set up your project.");
     process.exit(1);
   }