replicas-engine 0.1.1242 → 0.1.1244

package/dist/src/{chunk-MSM5OSLN.js → chunk-XQ5WSXBS.js}

@@ -1916,6 +1916,21 @@ var engineMcpOAuthTokenResponseSchema = z5.object({
   expires_at: z5.string().nullable()
 });
 
+// ../shared/src/routes/mothership.ts
+import { z as z6 } from "zod";
+var SUBAGENT_SERVICE_TIERS = ["default", "fast", "ultrafast"];
+function serviceTierRequestFields(tier) {
+  return { fastMode: tier !== "default", ...tier === "ultrafast" ? { ultrafastMode: true } : {} };
+}
+var mothershipSubagentSettingsSchema = z6.object({
+  coding_agent: z6.enum(VALID_AGENT_PROVIDERS),
+  model: z6.string().nullable(),
+  thinking_level: z6.enum(VALID_THINKING_LEVELS).nullable(),
+  service_tier: z6.enum(SUBAGENT_SERVICE_TIERS),
+  goal_mode: z6.boolean(),
+  plan_mode: z6.boolean()
+});
+
 // ../shared/src/runtime-env.ts
 var REPLICAS_RUNTIME_ENV_ALIASES = {
   monolithUrl: ["REPLICAS_MONOLITH_URL", "MONOLITH_URL"],
@@ -2105,19 +2120,19 @@ function gitIdentityConfigCommands(identity, scope = "global") {
 }
 
 // ../shared/src/headless-agent.ts
-import { z as z6 } from "zod";
-var headlessAgentRequestSchema = z6.object({
-  mode: z6.literal("structured"),
-  agent: z6.custom(
+import { z as z7 } from "zod";
+var headlessAgentRequestSchema = z7.object({
+  mode: z7.literal("structured"),
+  agent: z7.custom(
     (value) => typeof value === "string" && isValidAgentProvider(value)
   ),
-  model: z6.string().min(1),
-  prompt: z6.string(),
-  workingDirectory: z6.string().min(1),
-  timeoutSeconds: z6.number().int().min(1).max(1800).default(300),
-  thinkingLevel: z6.enum(STANDARD_THINKING_LEVELS).optional(),
-  codexOauthTokens: z6.object({ accessToken: z6.string(), accountId: z6.string() }).optional(),
-  outputSchema: z6.record(z6.string(), z6.json())
+  model: z7.string().min(1),
+  prompt: z7.string(),
+  workingDirectory: z7.string().min(1),
+  timeoutSeconds: z7.number().int().min(1).max(1800).default(300),
+  thinkingLevel: z7.enum(STANDARD_THINKING_LEVELS).optional(),
+  codexOauthTokens: z7.object({ accessToken: z7.string(), accountId: z7.string() }).optional(),
+  outputSchema: z7.record(z7.string(), z7.json())
 });
 var headlessAgentUsagePath = (outputPath) => `${outputPath}.usage`;
 
@@ -2193,12 +2208,12 @@ function describeAuthFallback(payload) {
 }
 
 // ../shared/src/workspace-credentials.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 var WORKSPACE_CREDENTIAL_PROVIDERS = ["claude", "codex"];
-var workspaceCredentialProviderSchema = z7.enum(WORKSPACE_CREDENTIAL_PROVIDERS);
+var workspaceCredentialProviderSchema = z8.enum(WORKSPACE_CREDENTIAL_PROVIDERS);
 var workspaceCredentialSelectionSchema = agentCredentialSnapshotSchema.omit({ revision: true, account: true, credentialId: true });
 var createWorkspaceCredentialSchema = workspaceCredentialSelectionSchema.extend({
-  provider: z7.enum(VALID_AGENT_PROVIDERS)
+  provider: z8.enum(VALID_AGENT_PROVIDERS)
 }).refine(({ provider: provider2, method }) => agentCredentialMethods(provider2).includes(method), {
   message: "This inference provider is not supported by this agent"
 });
@@ -2209,59 +2224,59 @@ var switchWorkspaceCredentialSchema = workspaceCredentialSelectionSchema.extend(
 });
 
 // ../shared/src/chat-fork.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // ../shared/src/fallback-chains.ts
-import { z as z8 } from "zod";
-var fallbackHarnessStepSchema = z8.object({
-  kind: z8.literal("harness"),
-  provider: z8.enum(VALID_AGENT_PROVIDERS),
-  model: z8.string().min(1),
-  thinkingLevel: z8.enum(VALID_THINKING_LEVELS).optional()
+import { z as z9 } from "zod";
+var fallbackHarnessStepSchema = z9.object({
+  kind: z9.literal("harness"),
+  provider: z9.enum(VALID_AGENT_PROVIDERS),
+  model: z9.string().min(1),
+  thinkingLevel: z9.enum(VALID_THINKING_LEVELS).optional()
 });
-var fallbackPlanStepSchema = z8.discriminatedUnion("kind", [
-  z8.object({
-    kind: z8.literal("credentials"),
-    methods: z8.array(z8.custom(isAuthMethod)).min(1),
-    models: z8.record(z8.string(), z8.string().min(1)).optional()
+var fallbackPlanStepSchema = z9.discriminatedUnion("kind", [
+  z9.object({
+    kind: z9.literal("credentials"),
+    methods: z9.array(z9.custom(isAuthMethod)).min(1),
+    models: z9.record(z9.string(), z9.string().min(1)).optional()
   }),
   fallbackHarnessStepSchema
 ]);
-var fallbackPlanResponseSchema = z8.object({ steps: z8.array(fallbackPlanStepSchema) });
+var fallbackPlanResponseSchema = z9.object({ steps: z9.array(fallbackPlanStepSchema) });
 
 // ../shared/src/chat-fork.ts
-var fallbackReasonSchema = z9.enum(AGENT_FALLBACK_REASONS);
-var chatForkInfoSchema = z9.object({
-  source: z9.object({
-    chatId: z9.string().min(1),
-    provider: z9.enum(VALID_AGENT_PROVIDERS),
-    title: z9.string()
+var fallbackReasonSchema = z10.enum(AGENT_FALLBACK_REASONS);
+var chatForkInfoSchema = z10.object({
+  source: z10.object({
+    chatId: z10.string().min(1),
+    provider: z10.enum(VALID_AGENT_PROVIDERS),
+    title: z10.string()
   }),
-  trigger: z9.enum(["manual", "auto", "side"]),
+  trigger: z10.enum(["manual", "auto", "side"]),
   reason: fallbackReasonSchema.optional(),
-  state: z9.enum(["preparing", "ready", "failed"]),
-  error: z9.string().optional(),
-  startedAt: z9.string(),
-  completedAt: z9.string().optional()
+  state: z10.enum(["preparing", "ready", "failed"]),
+  error: z10.string().optional(),
+  startedAt: z10.string(),
+  completedAt: z10.string().optional()
 });
 function coerceChatForkInfo(value) {
   const parsed = chatForkInfoSchema.safeParse(value);
   return parsed.success ? parsed.data : null;
 }
-var forkChatRequestSchema = z9.object({
-  provider: z9.enum(VALID_AGENT_PROVIDERS),
-  model: z9.string().min(1).optional(),
-  thinkingLevel: z9.enum(VALID_THINKING_LEVELS).optional(),
-  title: z9.string().min(1).max(200).optional(),
-  message: z9.string().trim().optional(),
-  id: z9.string().uuid().optional(),
-  clientRequestId: z9.string().min(1).max(128).optional(),
-  enableInteractiveTools: z9.boolean().optional(),
+var forkChatRequestSchema = z10.object({
+  provider: z10.enum(VALID_AGENT_PROVIDERS),
+  model: z10.string().min(1).optional(),
+  thinkingLevel: z10.enum(VALID_THINKING_LEVELS).optional(),
+  title: z10.string().min(1).max(200).optional(),
+  message: z10.string().trim().optional(),
+  id: z10.string().uuid().optional(),
+  clientRequestId: z10.string().min(1).max(128).optional(),
+  enableInteractiveTools: z10.boolean().optional(),
   // Server-injected by the monolith from the authenticated request; never trusted from clients.
-  senderUserId: z9.string().optional(),
-  senderEmail: z9.string().optional(),
-  senderDisplayName: z9.string().optional(),
-  senderAvatarUrl: z9.string().optional()
+  senderUserId: z10.string().optional(),
+  senderEmail: z10.string().optional(),
+  senderDisplayName: z10.string().optional(),
+  senderAvatarUrl: z10.string().optional()
 });
 function describeQuotaLimit(reason) {
   if (reason === "auth_failed") return "could not authenticate";
@@ -2272,10 +2287,10 @@ function describeChatForkReason(reason, provider2) {
   return reason ? `${getProviderDisplayName(provider2)} ${describeQuotaLimit(reason)}` : null;
 }
 var AGENT_QUOTA_EXHAUSTED_EVENT_TYPE = "agent-quota-exhausted";
-var agentQuotaExhaustedPayloadSchema = z9.object({
-  provider: z9.enum(VALID_AGENT_PROVIDERS),
+var agentQuotaExhaustedPayloadSchema = z10.object({
+  provider: z10.enum(VALID_AGENT_PROVIDERS),
   reason: fallbackReasonSchema,
-  detail: z9.string().optional(),
+  detail: z10.string().optional(),
   forkTo: fallbackHarnessStepSchema.optional()
 });
 function defaultForkChatTitle(source, provider2) {
@@ -2289,27 +2304,27 @@ function getChatContinuation(chats, chatId) {
 }
 
 // ../shared/src/credential-refresh.ts
-import { z as z10 } from "zod";
-var engineCredentialRefreshFailureSchema = z10.object({
-  code: z10.string(),
+import { z as z11 } from "zod";
+var engineCredentialRefreshFailureSchema = z11.object({
+  code: z11.string(),
   credential: workspaceCredentialSelectionSchema.optional()
 });
 
 // ../shared/src/credential-pool.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var MAX_CREDENTIAL_POOL_ACCOUNTS = 10;
-var reorderCredentialPoolSchema = z11.object({
-  credential_ids: z11.array(z11.string().uuid()).min(1).max(MAX_CREDENTIAL_POOL_ACCOUNTS)
+var reorderCredentialPoolSchema = z12.object({
+  credential_ids: z12.array(z12.string().uuid()).min(1).max(MAX_CREDENTIAL_POOL_ACCOUNTS)
 });
 
 // ../shared/src/mothership-events.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // ../shared/src/replicas-mcp.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // ../shared/src/automations/trigger-schemas.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // ../shared/src/uuid.ts
 function createUuidFromHex(value) {
@@ -2326,29 +2341,29 @@ function getReviewerLoginsError(event, logins) {
   if (isReviewRequested === !!logins?.some((login) => login.trim().replace(/^@+/, ""))) return null;
   return isReviewRequested ? "The PR review requested trigger needs at least one GitHub username" : "Requested reviewers only apply to the PR review requested trigger";
 }
-var repositoryTriggerConfigSchema = z12.object({
-  event: z12.string(),
-  repository_ids: z12.array(z12.string().regex(UUID_RE, "must be a repository id")).optional(),
-  group_pr_events: z12.boolean().optional(),
-  excluded_actors: z12.array(z12.string()).optional(),
-  reviewer_logins: z12.array(z12.string()).optional()
+var repositoryTriggerConfigSchema = z13.object({
+  event: z13.string(),
+  repository_ids: z13.array(z13.string().regex(UUID_RE, "must be a repository id")).optional(),
+  group_pr_events: z13.boolean().optional(),
+  excluded_actors: z13.array(z13.string()).optional(),
+  reviewer_logins: z13.array(z13.string()).optional()
 });
-var cronTriggerSchema = z12.object({ type: z12.literal("cron"), config: z12.object({ schedule: z12.string(), timezone: z12.string().optional() }) });
-var githubTriggerSchema = z12.object({
-  type: z12.literal("github"),
+var cronTriggerSchema = z13.object({ type: z13.literal("cron"), config: z13.object({ schedule: z13.string(), timezone: z13.string().optional() }) });
+var githubTriggerSchema = z13.object({
+  type: z13.literal("github"),
   config: repositoryTriggerConfigSchema.superRefine((config, ctx) => {
     const message2 = getReviewerLoginsError(config.event, config.reviewer_logins);
     if (message2) ctx.addIssue({ code: "custom", message: message2, path: ["reviewer_logins"] });
   })
 });
-var gitlabTriggerSchema = z12.object({ type: z12.literal("gitlab"), config: repositoryTriggerConfigSchema });
-var automationTriggerSchema = z12.discriminatedUnion("type", [
+var gitlabTriggerSchema = z13.object({ type: z13.literal("gitlab"), config: repositoryTriggerConfigSchema });
+var automationTriggerSchema = z13.discriminatedUnion("type", [
   cronTriggerSchema,
   githubTriggerSchema,
   gitlabTriggerSchema,
-  z12.object({ type: z12.literal("slack"), config: z12.object({ event: z12.string(), channel_ids: z12.array(z12.string()).optional(), group_thread_replies: z12.boolean().optional() }) }),
-  z12.object({ type: z12.literal("sentry"), config: z12.object({ event: z12.string(), project_slugs: z12.array(z12.string()).optional(), min_level: z12.string().optional() }) }),
-  z12.object({ type: z12.literal("custom"), config: z12.object({}) })
+  z13.object({ type: z13.literal("slack"), config: z13.object({ event: z13.string(), channel_ids: z13.array(z13.string()).optional(), group_thread_replies: z13.boolean().optional() }) }),
+  z13.object({ type: z13.literal("sentry"), config: z13.object({ event: z13.string(), project_slugs: z13.array(z13.string()).optional(), min_level: z13.string().optional() }) }),
+  z13.object({ type: z13.literal("custom"), config: z13.object({}) })
 ]);
 
 // ../shared/src/automations/types.ts
@@ -2356,21 +2371,21 @@ var AUTOMATION_DEBOUNCE_MAX_SECONDS = 24 * 60 * 60;
 var AUTOMATION_LIFECYCLE_POLICIES = ["default", "archive_when_done", "sleep_when_done", "delete_when_done"];
 
 // ../shared/src/routes/environment.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 var ENVIRONMENT_MCP_TRANSPORTS = ["stdio", "http", "sse"];
-var stringMap = z13.record(z13.string(), z13.string());
-var createEnvironmentMcpRequestSchema = z13.object({
-  name: z13.string(),
-  transport: z13.enum(ENVIRONMENT_MCP_TRANSPORTS),
-  config: z13.union([
-    z13.object({ command: z13.string().min(1), args: z13.array(z13.string()).optional(), env: stringMap.optional() }),
-    z13.object({ url: z13.url(), headers: stringMap.optional(), auth: mcpAuthSchema.optional() })
+var stringMap = z14.record(z14.string(), z14.string());
+var createEnvironmentMcpRequestSchema = z14.object({
+  name: z14.string(),
+  transport: z14.enum(ENVIRONMENT_MCP_TRANSPORTS),
+  config: z14.union([
+    z14.object({ command: z14.string().min(1), args: z14.array(z14.string()).optional(), env: stringMap.optional() }),
+    z14.object({ url: z14.url(), headers: stringMap.optional(), auth: mcpAuthSchema.optional() })
   ]).describe("stdio: `{ command, args, env }`. http/sse: `{ url, headers }`.")
 });
 var updateEnvironmentMcpRequestSchema = createEnvironmentMcpRequestSchema.partial();
 
 // ../shared/src/routes/workspaces.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 var WORKSPACE_STATUSES = ["active", "sleeping", "archived", "preparing", "error"];
 var STALE_PREPARING_MS = 10 * 6e4;
 var WORKSPACE_STATUS_FILTERS = WORKSPACE_STATUSES.map((status) => status === "error" ? "failed" : status);
@@ -2381,16 +2396,16 @@ var DEFAULT_WORKSPACE_FILTERS = {
   activity: "any"
 };
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var workspaceExecRequestSchema = z14.object({
-  command: z14.string().regex(/\S/, "command is required"),
-  timeout_seconds: z14.number().int().min(1).max(50).optional().describe("Default: 30")
+var workspaceExecRequestSchema = z15.object({
+  command: z15.string().regex(/\S/, "command is required"),
+  timeout_seconds: z15.number().int().min(1).max(50).optional().describe("Default: 30")
 });
-var terminalRtcCandidateSchema = z14.object({ type: z14.literal("rtc-candidate"), candidate: z14.string(), mid: z14.string() });
-var terminalSocketServerMessageSchema = z14.discriminatedUnion("type", [
-  z14.object({ type: z14.literal("output"), data: z14.string() }),
-  z14.object({ type: z14.literal("rtc-answer"), sdp: z14.string() }),
+var terminalRtcCandidateSchema = z15.object({ type: z15.literal("rtc-candidate"), candidate: z15.string(), mid: z15.string() });
+var terminalSocketServerMessageSchema = z15.discriminatedUnion("type", [
+  z15.object({ type: z15.literal("output"), data: z15.string() }),
+  z15.object({ type: z15.literal("rtc-answer"), sdp: z15.string() }),
   terminalRtcCandidateSchema,
-  z14.object({ type: z14.literal("rtc-switch") })
+  z15.object({ type: z15.literal("rtc-switch") })
 ]);
 var TERMINAL_RTC_ICE_SERVER = "stun:stun.l.google.com:19302";
 
@@ -2433,44 +2448,44 @@ var REPLICAS_MCP_TOOLS = {
   deleteChat: "delete_chat",
   listRepositories: "list_repositories"
 };
-var automationToolInputSchema = z15.object({
-  name: z15.string().describe("Short automation name."),
-  prompt: z15.string().describe("Prompt each automation run starts with."),
-  environment_id: z15.string().describe(`Environment id from \`${REPLICAS_MCP_TOOLS.listEnvironments}\`.`),
-  triggers: z15.array(automationTriggerSchema).min(1).describe(
+var automationToolInputSchema = z16.object({
+  name: z16.string().describe("Short automation name."),
+  prompt: z16.string().describe("Prompt each automation run starts with."),
+  environment_id: z16.string().describe(`Environment id from \`${REPLICAS_MCP_TOOLS.listEnvironments}\`.`),
+  triggers: z16.array(automationTriggerSchema).min(1).describe(
     'One or more triggers. Cron: `{ "type": "cron", "config": { "schedule": "0 9 * * 1", "timezone": "America/New_York" } }`. GitHub: `{ "type": "github", "config": { "event": "pull_request.opened", "repository_ids": ["<repository uuid>"] } }`.'
   ),
-  description: z15.string().optional().describe("One-line summary shown in the dashboard."),
-  plan_mode: z15.boolean().optional(),
-  goal_mode: z15.boolean().optional(),
-  fast_mode: z15.boolean().optional(),
-  workspace_lifecycle_policy: z15.enum(AUTOMATION_LIFECYCLE_POLICIES).optional().describe(
+  description: z16.string().optional().describe("One-line summary shown in the dashboard."),
+  plan_mode: z16.boolean().optional(),
+  goal_mode: z16.boolean().optional(),
+  fast_mode: z16.boolean().optional(),
+  workspace_lifecycle_policy: z16.enum(AUTOMATION_LIFECYCLE_POLICIES).optional().describe(
     "What happens to a run's workspace when the agent finishes. `delete_when_done` (default) when the output lives elsewhere (PR comments, checks, Slack posts); `sleep_when_done` when later runs reuse the workspace, like one per PR across pushes; `default` (keep alive) when people follow up in the workspace."
   )
 });
 var automationCreateToolInputSchema = automationToolInputSchema.extend({
-  scope: z15.enum(["org", "user"]).optional().describe("`org` (default) or `user` for a personal automation, which needs a personal API key.")
+  scope: z16.enum(["org", "user"]).optional().describe("`org` (default) or `user` for a personal automation, which needs a personal API key.")
 });
 var automationUpdateToolInputSchema = automationToolInputSchema.partial().extend({
-  automation_id: z15.string().describe("Automation ID"),
-  enabled: z15.boolean().optional(),
-  agent_provider: z15.enum(AGENT).nullable().optional(),
-  model: z15.string().nullable().optional(),
-  thinking_level: z15.enum(VALID_THINKING_LEVELS).nullable().optional(),
-  workspace_size: z15.enum(WORKSPACE_SIZES).optional(),
-  scope: z15.literal("org").optional().describe("`org` moves a personal automation to the organization so teammates can see and edit it. It cannot be moved back.")
+  automation_id: z16.string().describe("Automation ID"),
+  enabled: z16.boolean().optional(),
+  agent_provider: z16.enum(AGENT).nullable().optional(),
+  model: z16.string().nullable().optional(),
+  thinking_level: z16.enum(VALID_THINKING_LEVELS).nullable().optional(),
+  workspace_size: z16.enum(WORKSPACE_SIZES).optional(),
+  scope: z16.literal("org").optional().describe("`org` moves a personal automation to the organization so teammates can see and edit it. It cannot be moved back.")
 });
-var chatPath = { id: z15.string().describe("Workspace ID"), chat_id: z15.string().describe("Chat ID") };
+var chatPath = { id: z16.string().describe("Workspace ID"), chat_id: z16.string().describe("Chat ID") };
 var { provider, model, thinkingLevel, title, message } = forkChatRequestSchema.shape;
-var createChatToolInputSchema = z15.object({ id: chatPath.id, provider, title: createChatRequestSchema.shape.title });
-var forkChatToolInputSchema = z15.object({ ...chatPath, provider, model, thinking_level: thinkingLevel, title, message });
-var renameChatToolInputSchema = z15.object({ ...chatPath, display_name: updateChatDisplayNameRequestSchema.shape.displayName });
-var runCommandToolInputSchema = z15.object({ id: chatPath.id, ...workspaceExecRequestSchema.shape });
-var environmentMcpPath = { environment_id: z15.string().describe("Environment ID") };
-var createEnvironmentMcpToolInputSchema = z15.object({ ...environmentMcpPath, ...createEnvironmentMcpRequestSchema.shape });
-var updateEnvironmentMcpToolInputSchema = z15.object({
+var createChatToolInputSchema = z16.object({ id: chatPath.id, provider, title: createChatRequestSchema.shape.title });
+var forkChatToolInputSchema = z16.object({ ...chatPath, provider, model, thinking_level: thinkingLevel, title, message });
+var renameChatToolInputSchema = z16.object({ ...chatPath, display_name: updateChatDisplayNameRequestSchema.shape.displayName });
+var runCommandToolInputSchema = z16.object({ id: chatPath.id, ...workspaceExecRequestSchema.shape });
+var environmentMcpPath = { environment_id: z16.string().describe("Environment ID") };
+var createEnvironmentMcpToolInputSchema = z16.object({ ...environmentMcpPath, ...createEnvironmentMcpRequestSchema.shape });
+var updateEnvironmentMcpToolInputSchema = z16.object({
   ...environmentMcpPath,
-  mcp_id: z15.string().describe("MCP ID"),
+  mcp_id: z16.string().describe("MCP ID"),
   ...updateEnvironmentMcpRequestSchema.shape
 });
 
@@ -2775,7 +2790,7 @@ var DOCKER_ABILITY = {
 };
 
 // ../shared/src/routes/environment-setups.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 var ENVIRONMENT_SETUP_STEPS = [
   { key: "understand", label: "Understand the codebase" },
   { key: "install", label: "Install dependencies and run the app" },
@@ -2808,17 +2823,17 @@ var ENVIRONMENT_SETUP_LIMITS = {
   repositories: 20
 };
 var VARIABLE_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var text2 = (max) => max === void 0 ? z16.string().trim() : z16.string().trim().max(max);
+var text2 = (max) => max === void 0 ? z17.string().trim() : z17.string().trim().max(max);
 var requiredText = (max) => text2(max).min(1, "must not be empty");
 var optionalText2 = (max) => text2(max).nullish().transform((value) => value || null);
 var clearableText = (max) => text2(max).nullish().transform((value) => value === void 0 ? void 0 : value || null);
-var list = (item, max) => max === void 0 ? z16.array(item) : z16.array(item).max(max);
+var list = (item, max) => max === void 0 ? z17.array(item) : z17.array(item).max(max);
 var ENVIRONMENT_SETUP_AUTHORED_TRIGGER_TYPES = ["cron", "github", "gitlab"];
 function isEnvironmentSetupAuthoredTriggerType(type) {
   return ENVIRONMENT_SETUP_AUTHORED_TRIGGER_TYPES.some((authored) => authored === type);
 }
-var proposalTriggerSchema = z16.discriminatedUnion("type", [cronTriggerSchema, githubTriggerSchema, gitlabTriggerSchema]);
-var existingTriggerSchema = z16.custom(
+var proposalTriggerSchema = z17.discriminatedUnion("type", [cronTriggerSchema, githubTriggerSchema, gitlabTriggerSchema]);
+var existingTriggerSchema = z17.custom(
   (value) => isRecord(value) && typeof value.type === "string" && isRecord(value.config),
   "must be an automation trigger"
 );
@@ -2826,17 +2841,17 @@ var carriedTriggerSchema = existingTriggerSchema.refine(
   (trigger) => !isEnvironmentSetupAuthoredTriggerType(trigger.type)
 );
 function automationSchema(limits) {
-  const authored = z16.object({
+  const authored = z17.object({
     name: text2(limits.nameChars),
     description: text2(limits.descriptionChars),
     prompt: text2(limits.automationPromptChars),
     triggers: list(proposalTriggerSchema, limits.automationTriggers)
   });
-  const updated = authored.extend({ triggers: list(z16.union([proposalTriggerSchema, carriedTriggerSchema]), limits.automationTriggers) });
-  return z16.object({
+  const updated = authored.extend({ triggers: list(z17.union([proposalTriggerSchema, carriedTriggerSchema]), limits.automationTriggers) });
+  return z17.object({
     key: requiredText(limits.automationKeyChars),
-    action: z16.enum(ENVIRONMENT_SETUP_AUTOMATION_ACTIONS).default("create"),
-    automation_id: z16.string().regex(UUID_RE, "must be an automation id").nullable().default(null),
+    action: z17.enum(ENVIRONMENT_SETUP_AUTOMATION_ACTIONS).default("create"),
+    automation_id: z17.string().regex(UUID_RE, "must be an automation id").nullable().default(null),
     name: text2().default(""),
     description: optionalText2().transform((value) => value ?? ""),
     prompt: text2().default(""),
@@ -2859,7 +2874,7 @@ function automationSchema(limits) {
     const content = (automation.action === "update" ? updated : authored).safeParse(automation);
     if (content.success) return { ...automation, ...content.data };
     for (const issue of content.error.issues) ctx.addIssue({ ...issue, code: "custom" });
-    return z16.NEVER;
+    return z17.NEVER;
   });
 }
 function automationListSchema(limits) {
@@ -2877,7 +2892,7 @@ function automationListSchema(limits) {
   });
 }
 function environmentSchema(limits) {
-  return z16.object({
+  return z17.object({
     name: optionalText2(limits.nameChars).transform((value) => value ?? void 0),
     description: clearableText(limits.descriptionChars),
     system_prompt: clearableText(limits.systemPromptChars),
@@ -2886,41 +2901,41 @@ function environmentSchema(limits) {
   });
 }
 function proposalSchema(limits) {
-  return z16.object({
+  return z17.object({
     summary: requiredText(limits.summaryChars),
     stack: list(text2(), limits.stackItems).default([]).transform((items) => items.filter(Boolean)),
     environment: environmentSchema(limits),
-    variables: list(z16.object({
-      key: z16.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(limits.variableKeyChars ?? Number.POSITIVE_INFINITY),
+    variables: list(z17.object({
+      key: z17.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(limits.variableKeyChars ?? Number.POSITIVE_INFINITY),
       description: optionalText2(limits.variableDescriptionChars).transform((value) => value ?? ""),
-      required: z16.boolean().default(false)
+      required: z17.boolean().default(false)
     }), limits.variables).default([]),
     automations: automationListSchema(limits),
-    verification: list(z16.object({
+    verification: list(z17.object({
       label: requiredText(limits.nameChars),
-      status: z16.enum(ENVIRONMENT_SETUP_VERIFICATION_STATUSES),
+      status: z17.enum(ENVIRONMENT_SETUP_VERIFICATION_STATUSES),
       detail: optionalText2(limits.verificationDetailChars).transform((value) => value ?? void 0)
     }), limits.verificationItems).default([]),
-    media: list(z16.object({
-      media_id: z16.string().regex(UUID_RE, "must be a media id"),
+    media: list(z17.object({
+      media_id: z17.string().regex(UUID_RE, "must be a media id"),
       title: requiredText(limits.nameChars)
     }), limits.mediaItems).default([])
   });
 }
 var environmentSetupProposalSchema = proposalSchema({});
 var environmentSetupProposalSubmissionSchema = proposalSchema(ENVIRONMENT_SETUP_LIMITS);
-var environmentSetupRunStateSchema = z16.object({
-  status: z16.enum(ENVIRONMENT_SETUP_RUN_STATUSES),
-  steps: z16.partialRecord(z16.enum(ENVIRONMENT_SETUP_STEPS.map((step) => step.key)), z16.enum(ENVIRONMENT_SETUP_STEP_STATUSES)).default({}),
+var environmentSetupRunStateSchema = z17.object({
+  status: z17.enum(ENVIRONMENT_SETUP_RUN_STATUSES),
+  steps: z17.partialRecord(z17.enum(ENVIRONMENT_SETUP_STEPS.map((step) => step.key)), z17.enum(ENVIRONMENT_SETUP_STEP_STATUSES)).default({}),
   proposal: environmentSetupProposalSchema.nullable().default(null),
-  applied: z16.object({
-    applied_at: z16.string(),
-    automation_ids: z16.array(z16.string())
+  applied: z17.object({
+    applied_at: z17.string(),
+    automation_ids: z17.array(z17.string())
   }).nullable().default(null)
 });
-var applyEnvironmentSetupRequestSchema = z16.object({
+var applyEnvironmentSetupRequestSchema = z17.object({
   environment: environmentSchema(ENVIRONMENT_SETUP_LIMITS).extend({ name: requiredText(ENVIRONMENT_SETUP_LIMITS.nameChars) }),
-  variables: list(z16.object({ key: z16.string().regex(VARIABLE_KEY_RE), value: z16.string() }), ENVIRONMENT_SETUP_LIMITS.variables).default([]).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys").transform((variables) => variables.filter((variable) => variable.value.length > 0)),
+  variables: list(z17.object({ key: z17.string().regex(VARIABLE_KEY_RE), value: z17.string() }), ENVIRONMENT_SETUP_LIMITS.variables).default([]).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys").transform((variables) => variables.filter((variable) => variable.value.length > 0)),
   automations: automationListSchema(ENVIRONMENT_SETUP_LIMITS)
 });
 
@@ -3373,7 +3388,7 @@ var GITLAB_ABILITY = {
 };
 
 // ../shared/src/routes/compute.ts
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var COMPUTE_SANDBOX_KINDS = ["gpu"];
 var GPU_TYPES = ["T4", "L4", "A10G", "L40S", "A100", "A100-80GB", "H100", "H200", "B200"];
 var DEFAULT_GPU_TYPE = "L4";
@@ -3390,27 +3405,27 @@ var COMPUTE_SANDBOX_LIMITS = {
   maxIdleTimeoutMinutes: 60,
   maxTransferBytes: 1024 ** 3
 };
-var computeEnvSchema = z17.record(z17.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z17.string().max(32768)).refine((env) => Object.keys(env).length <= 64, "At most 64 environment variables are allowed");
-var createComputeSandboxRequestSchema = z17.object({
-  kind: z17.enum(COMPUTE_SANDBOX_KINDS),
-  gpu: z17.string().trim().optional(),
-  image: z17.string().trim().min(1).max(256).regex(/^\S+$/, "Image must not contain whitespace").optional(),
-  timeoutMinutes: z17.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTimeoutMinutes).optional(),
-  idleTimeoutMinutes: z17.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxIdleTimeoutMinutes).optional(),
-  ports: z17.array(z17.number().int().min(1).max(65535)).max(COMPUTE_SANDBOX_LIMITS.maxPorts).optional(),
+var computeEnvSchema = z18.record(z18.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z18.string().max(32768)).refine((env) => Object.keys(env).length <= 64, "At most 64 environment variables are allowed");
+var createComputeSandboxRequestSchema = z18.object({
+  kind: z18.enum(COMPUTE_SANDBOX_KINDS),
+  gpu: z18.string().trim().optional(),
+  image: z18.string().trim().min(1).max(256).regex(/^\S+$/, "Image must not contain whitespace").optional(),
+  timeoutMinutes: z18.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTimeoutMinutes).optional(),
+  idleTimeoutMinutes: z18.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxIdleTimeoutMinutes).optional(),
+  ports: z18.array(z18.number().int().min(1).max(65535)).max(COMPUTE_SANDBOX_LIMITS.maxPorts).optional(),
   env: computeEnvSchema.optional()
 });
-var computeExecRequestSchema = z17.object({
-  command: z17.string().min(1).max(1e5),
-  workdir: z17.string().min(1).max(4096).optional(),
+var computeExecRequestSchema = z18.object({
+  command: z18.string().min(1).max(1e5),
+  workdir: z18.string().min(1).max(4096).optional(),
   env: computeEnvSchema.optional(),
-  detach: z17.boolean().optional()
+  detach: z18.boolean().optional()
 });
-var computeUploadRequestSchema = z17.object({
-  size: z17.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTransferBytes)
+var computeUploadRequestSchema = z18.object({
+  size: z18.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTransferBytes)
 });
-var computeTransferPathSchema = z17.object({
-  path: z17.string().min(1).max(4096).optional()
+var computeTransferPathSchema = z18.object({
+  path: z18.string().min(1).max(4096).optional()
 });
 
 // ../shared/src/default-skills/replicas-agent/abilities/gpu.ts
@@ -5030,16 +5045,16 @@ function splitMothershipInstructions(customInstructions) {
 // ../shared/src/mothership-events.ts
 var MOTHERSHIP_EVENT_KINDS = ["finished", "ready", "needs_attention", "merged", "closed", "archived"];
 var MOTHERSHIP_EVENT_TYPE = "multitask-event";
-var mothershipEventSchema = z18.object({
-  id: z18.string(),
-  at: z18.string(),
-  kind: z18.enum(MOTHERSHIP_EVENT_KINDS),
-  agentId: z18.string(),
-  agentName: z18.string(),
-  summary: z18.string(),
-  detail: z18.string().optional(),
+var mothershipEventSchema = z19.object({
+  id: z19.string(),
+  at: z19.string(),
+  kind: z19.enum(MOTHERSHIP_EVENT_KINDS),
+  agentId: z19.string(),
+  agentName: z19.string(),
+  summary: z19.string(),
+  detail: z19.string().optional(),
   // Set on events recorded before every kind woke the orchestrator, which were shown as a row when they happened.
-  noticed: z18.boolean().optional()
+  noticed: z19.boolean().optional()
 });
 var TAG = "multitask_event";
 var BLOCK = new RegExp(`<${TAG}((?:\\s+\\w+="[^"]*")*)>\\n?([\\s\\S]*?)\\n?</${TAG}>`, "g");
@@ -5796,7 +5811,7 @@ function parseMcpToolName(name) {
 }
 
 // ../shared/src/learned-skills.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 
 // ../shared/src/frontmatter.ts
 import { parse as parseYaml } from "yaml";
@@ -5819,20 +5834,20 @@ function parseFrontmatter(content) {
 var LEARNED_SKILLS_ROOT = `${SANDBOX_PATHS.REPLICAS_DIR}/learned-skills`;
 var LEARNED_SKILLS_MANIFEST_PATH = `${LEARNED_SKILLS_ROOT}/manifest.json`;
 var LEARNED_SKILL_DIR_PREFIX = "replicas-learned__";
-var learnedSkillsManifestSchema = z19.object({
-  skills: z19.array(z19.object({ name: z19.string(), sha256: z19.string() }))
+var learnedSkillsManifestSchema = z20.object({
+  skills: z20.array(z20.object({ name: z20.string(), sha256: z20.string() }))
 });
-var dreamVerdictChecksSchema = z19.object({
-  repeatable: z19.boolean(),
-  realInstruction: z19.boolean(),
-  noContradiction: z19.boolean(),
-  formatExact: z19.boolean(),
-  humanOnly: z19.boolean(),
-  actionable: z19.boolean(),
-  durable: z19.boolean()
+var dreamVerdictChecksSchema = z20.object({
+  repeatable: z20.boolean(),
+  realInstruction: z20.boolean(),
+  noContradiction: z20.boolean(),
+  formatExact: z20.boolean(),
+  humanOnly: z20.boolean(),
+  actionable: z20.boolean(),
+  durable: z20.boolean()
 });
 var DREAM_VERDICT_CHECKS = dreamVerdictChecksSchema.keyof().options;
-var dreamVerdictSchema = dreamVerdictChecksSchema.extend({ approve: z19.boolean(), reason: z19.string() });
+var dreamVerdictSchema = dreamVerdictChecksSchema.extend({ approve: z20.boolean(), reason: z20.string() });
 var learnedSkillFormatInstruction = (speaker) => `Write a SKILL.md whose frontmatter has a kebab-case \`name\` and a short \`description\` that starts with "Use when" and names the situations it applies to; the body records only what ${speaker} actually said, restated as a direct instruction, usually one to three lines. Every line of a learning is loaded into future sessions, so leave out anything an agent could infer on its own: no headings, explanations, rules, or examples unless ${speaker} stated those specifics themselves. For "from now on, use Conventional Commits", the body is just "Use Conventional Commits for every commit message and PR title."`;
 
 // ../shared/src/user-message-matching.ts
@@ -9124,7 +9139,7 @@ var CLAUDE_AUTH_ENV_KEYS_BY_METHOD = {
 };
 
 // ../shared/src/routes/command-protection.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // ../shared/src/git-invocations.ts
 var COMMIT_VALUE_OPTIONS = /* @__PURE__ */ new Set(["message", "file", "trailer", "reuse-message", "reedit-message", "fixup", "squash", "template", "author", "date", "cleanup", "pathspec-from-file"]);
@@ -9215,27 +9230,27 @@ function findCheckoutTarget(args) {
 }
 
 // ../shared/src/routes/command-protection.ts
-var commandProtectionRepoStateSchema = z20.object({
-  branch: z20.string().nullable(),
-  defaultBranch: z20.string().nullable(),
-  pushBranch: z20.string().nullable(),
-  pushConfig: z20.string().nullable(),
-  headMessage: z20.string().nullable(),
-  mergeInProgress: z20.boolean().optional()
+var commandProtectionRepoStateSchema = z21.object({
+  branch: z21.string().nullable(),
+  defaultBranch: z21.string().nullable(),
+  pushBranch: z21.string().nullable(),
+  pushConfig: z21.string().nullable(),
+  headMessage: z21.string().nullable(),
+  mergeInProgress: z21.boolean().optional()
 });
-var commandProtectionEvaluateRequestSchema = z20.object({
-  provider: z20.enum(["claude", "codex", "cursor", "opencode", "pi"]),
-  source: z20.enum(["claude_pre_tool_use", "codex_approval_request", "cursor_pre_tool_use", "opencode_pre_tool_use", "pi_tool_call"]),
-  toolName: z20.string(),
-  toolInput: z20.unknown(),
-  command: z20.string().nullish(),
-  cwd: z20.string().nullish(),
-  toolUseId: z20.string().nullish(),
+var commandProtectionEvaluateRequestSchema = z21.object({
+  provider: z21.enum(["claude", "codex", "cursor", "opencode", "pi"]),
+  source: z21.enum(["claude_pre_tool_use", "codex_approval_request", "cursor_pre_tool_use", "opencode_pre_tool_use", "pi_tool_call"]),
+  toolName: z21.string(),
+  toolInput: z21.unknown(),
+  command: z21.string().nullish(),
+  cwd: z21.string().nullish(),
+  toolUseId: z21.string().nullish(),
   // Read by the engine before the command runs, keyed by absolute path, so the
   // policy can see branches and commit messages the command text only references.
-  gitContext: z20.object({
-    repos: z20.record(z20.string(), commandProtectionRepoStateSchema),
-    messageFiles: z20.record(z20.string(), z20.string())
+  gitContext: z21.object({
+    repos: z21.record(z21.string(), commandProtectionRepoStateSchema),
+    messageFiles: z21.record(z21.string(), z21.string())
   }).optional()
 });
 var COMMAND_PROTECTION_COMMAND_KEYS = ["command", "cmd", "script", "query", "endpoint", "path", "url", "mutation"];
@@ -9432,113 +9447,113 @@ function shouldRefreshPullRequests(toolName, toolInput) {
 }
 
 // ../shared/src/routes/linear.ts
-import { z as z21 } from "zod";
-var linearSessionMetadataSchema = z21.object({
-  via_mothership: z21.boolean().optional(),
-  issue_id: z21.string(),
-  issue_identifier: z21.string(),
-  issue_title: z21.string(),
-  issue_description: z21.string(),
-  issue_url: z21.string(),
-  comment_id: z21.string(),
-  comment_body: z21.string(),
-  triggered_by_id: z21.string().optional(),
-  triggered_by_name: z21.string().optional(),
-  triggered_by_email: z21.string().optional(),
-  linear_workspace_id: z21.string().optional(),
-  creator_id: z21.string().optional(),
-  creator_name: z21.string().optional(),
-  creator_email: z21.string().optional(),
-  assignee_id: z21.string().optional(),
-  assignee_name: z21.string().optional(),
-  assignee_email: z21.string().optional(),
-  issue_state: z21.string().optional(),
-  parent_issue: z21.object({
-    id: z21.string(),
-    identifier: z21.string(),
-    title: z21.string(),
-    description: z21.string().nullable()
+import { z as z22 } from "zod";
+var linearSessionMetadataSchema = z22.object({
+  via_mothership: z22.boolean().optional(),
+  issue_id: z22.string(),
+  issue_identifier: z22.string(),
+  issue_title: z22.string(),
+  issue_description: z22.string(),
+  issue_url: z22.string(),
+  comment_id: z22.string(),
+  comment_body: z22.string(),
+  triggered_by_id: z22.string().optional(),
+  triggered_by_name: z22.string().optional(),
+  triggered_by_email: z22.string().optional(),
+  linear_workspace_id: z22.string().optional(),
+  creator_id: z22.string().optional(),
+  creator_name: z22.string().optional(),
+  creator_email: z22.string().optional(),
+  assignee_id: z22.string().optional(),
+  assignee_name: z22.string().optional(),
+  assignee_email: z22.string().optional(),
+  issue_state: z22.string().optional(),
+  parent_issue: z22.object({
+    id: z22.string(),
+    identifier: z22.string(),
+    title: z22.string(),
+    description: z22.string().nullable()
   }).optional(),
-  workspace: z21.object({
-    id: z21.string(),
-    coding_agent: z21.custom((value) => typeof value === "string" && isValidAgentProvider(value)),
-    task_description: z21.string(),
-    created_at: z21.string()
+  workspace: z22.object({
+    id: z22.string(),
+    coding_agent: z22.custom((value) => typeof value === "string" && isValidAgentProvider(value)),
+    task_description: z22.string(),
+    created_at: z22.string()
   }).optional()
 });
 
 // ../shared/src/routes/scout.ts
-import { z as z22 } from "zod";
+import { z as z23 } from "zod";
 var SCOUT_LINEAR_ACTIONS = ["ask", "start"];
-var scoutLinearSessionIntentRequestSchema = z22.object({
-  comment_id: z22.string().trim().min(1).describe("Id of the Linear comment the session will be created on."),
-  action: z22.enum(SCOUT_LINEAR_ACTIONS).describe("`ask` when the comment is a clarifying question, `start` when it hands off the task.")
+var scoutLinearSessionIntentRequestSchema = z23.object({
+  comment_id: z23.string().trim().min(1).describe("Id of the Linear comment the session will be created on."),
+  action: z23.enum(SCOUT_LINEAR_ACTIONS).describe("`ask` when the comment is a clarifying question, `start` when it hands off the task.")
 });
-var scoutLinearStartRequestSchema = z22.object({
-  issue_id: z22.string().describe("Linear issue id from the envelope's `issue_id`."),
-  agent_session_id: z22.string().describe("Existing Linear agent session id from the envelope's `agent_session_id`."),
-  prompt: z22.string().trim().min(1).describe("The latest request, in its author's words. The workspace already receives the issue and its comments.")
+var scoutLinearStartRequestSchema = z23.object({
+  issue_id: z23.string().describe("Linear issue id from the envelope's `issue_id`."),
+  agent_session_id: z23.string().describe("Existing Linear agent session id from the envelope's `agent_session_id`."),
+  prompt: z23.string().trim().min(1).describe("The latest request, in its author's words. The workspace already receives the issue and its comments.")
 });
-var slackChannelIdSchema = z22.string().describe("Slack channel id from the envelope's `channel_id`.");
-var slackThreadTsSchema = z22.string().describe("Slack thread timestamp from the envelope's `thread_ts`.");
-var scoutSlackSpawnRequestSchema = z22.object({
+var slackChannelIdSchema = z23.string().describe("Slack channel id from the envelope's `channel_id`.");
+var slackThreadTsSchema = z23.string().describe("Slack thread timestamp from the envelope's `thread_ts`.");
+var scoutSlackSpawnRequestSchema = z23.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message_ts: z22.string().describe("Timestamp of the Slack message that asked for the work (the envelope's `message_ts`). The server verifies this message and its author."),
-  user_id: z22.string().describe("Slack user id of that message's author (the envelope's `user_id`). The workspace is attributed to them."),
-  prompt: z22.string().describe("The person's request in their own words, quoting earlier messages only when it points to them. The workspace already receives the Slack thread, so add no research, plan, or guesses."),
-  acknowledgement_ts: z22.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the workspace link to it and tells the workspace not to acknowledge again."),
-  environment_id: z22.string().optional().describe(`Environment id from \`${REPLICAS_MCP_TOOLS.listEnvironments}\`. Pass it only when clearly confident it fits; omit it to let routing choose. If routing cannot choose, the call fails and nothing is posted, so pick one or ask the person.`)
+  message_ts: z23.string().describe("Timestamp of the Slack message that asked for the work (the envelope's `message_ts`). The server verifies this message and its author."),
+  user_id: z23.string().describe("Slack user id of that message's author (the envelope's `user_id`). The workspace is attributed to them."),
+  prompt: z23.string().describe("The person's request in their own words, quoting earlier messages only when it points to them. The workspace already receives the Slack thread, so add no research, plan, or guesses."),
+  acknowledgement_ts: z23.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the workspace link to it and tells the workspace not to acknowledge again."),
+  environment_id: z23.string().optional().describe(`Environment id from \`${REPLICAS_MCP_TOOLS.listEnvironments}\`. Pass it only when clearly confident it fits; omit it to let routing choose. If routing cannot choose, the call fails and nothing is posted, so pick one or ask the person.`)
 });
 var scoutSlackSpawnInNewThreadRequestSchema = scoutSlackSpawnRequestSchema.extend({
-  title: z22.string().trim().min(1).max(500).describe("One or two sentences stating the task, posted as the new top-level message."),
-  prompt: z22.string().describe("The person's request in their own words. The full source thread is attached as background, so add no summary, research, plan, or guesses."),
-  acknowledgement_ts: z22.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the new thread's link to it.")
+  title: z23.string().trim().min(1).max(500).describe("One or two sentences stating the task, posted as the new top-level message."),
+  prompt: z23.string().describe("The person's request in their own words. The full source thread is attached as background, so add no summary, research, plan, or guesses."),
+  acknowledgement_ts: z23.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the new thread's link to it.")
 });
-var scoutSlackRelayRequestSchema = z22.object({
+var scoutSlackRelayRequestSchema = z23.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message: z22.string().describe("The follow-up to deliver: every fresh message that belongs to this update, in its author's words, with no research, plan, or guesses added."),
-  user_id: z22.string().optional().describe("Slack user id of the follow-up's author (the envelope's `user_id`), so it is attributed to them. Defaults to the thread's original requester. Required with `workspace_id`."),
-  queue: z22.boolean().optional().describe("Set true only when the person explicitly asked for this to happen after the current task finishes. Delivers behind the active turn instead of interrupting it."),
-  workspace_id: z22.string().optional().describe(`Existing workspace id, from \`${REPLICAS_MCP_TOOLS.listWorkspaces}\` or a workspace link in the thread, to bind a thread without a workspace to before relaying. The author must be able to see it. Omit to relay into the thread's own workspace.`),
-  message_ts: z22.string().optional().describe("Timestamp of the Slack message that led to this relay (the envelope's `message_ts`). Required with `workspace_id`; the server verifies this message and its author.")
+  message: z23.string().describe("The follow-up to deliver: every fresh message that belongs to this update, in its author's words, with no research, plan, or guesses added."),
+  user_id: z23.string().optional().describe("Slack user id of the follow-up's author (the envelope's `user_id`), so it is attributed to them. Defaults to the thread's original requester. Required with `workspace_id`."),
+  queue: z23.boolean().optional().describe("Set true only when the person explicitly asked for this to happen after the current task finishes. Delivers behind the active turn instead of interrupting it."),
+  workspace_id: z23.string().optional().describe(`Existing workspace id, from \`${REPLICAS_MCP_TOOLS.listWorkspaces}\` or a workspace link in the thread, to bind a thread without a workspace to before relaying. The author must be able to see it. Omit to relay into the thread's own workspace.`),
+  message_ts: z23.string().optional().describe("Timestamp of the Slack message that led to this relay (the envelope's `message_ts`). Required with `workspace_id`; the server verifies this message and its author.")
 });
-var scoutSlackSetThreadMutedRequestSchema = z22.object({
+var scoutSlackSetThreadMutedRequestSchema = z23.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  muted: z22.boolean().describe("true to mute Replicas in this thread, false to unmute it.")
+  muted: z23.boolean().describe("true to mute Replicas in this thread, false to unmute it.")
 });
-var scoutListWorkspacesRequestSchema = z22.object({
+var scoutListWorkspacesRequestSchema = z23.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message_ts: z22.string().describe("The envelope's `message_ts`. The server verifies this message and its author."),
-  user_id: z22.string().describe("Slack user id of that message's author (the envelope's `user_id`). Only workspaces they can see are listed."),
-  query: z22.string().trim().min(1).optional().describe("Case-insensitive text to match against workspace names and pull request URLs.")
+  message_ts: z23.string().describe("The envelope's `message_ts`. The server verifies this message and its author."),
+  user_id: z23.string().describe("Slack user id of that message's author (the envelope's `user_id`). Only workspaces they can see are listed."),
+  query: z23.string().trim().min(1).optional().describe("Case-insensitive text to match against workspace names and pull request URLs.")
 });
-var scoutSlackConfirmationSchema = z22.object({
-  confirmation_channel_id: z22.string().describe("`channel_id` from the envelope of the Slack message that asked for or accepted this."),
-  confirmation_thread_ts: z22.string().describe("`thread_ts` from that message's envelope."),
-  confirmation_message_ts: z22.string().describe("`message_ts` from that message's envelope."),
-  confirmation_user_id: z22.string().describe("`user_id` from that message's envelope.")
+var scoutSlackConfirmationSchema = z23.object({
+  confirmation_channel_id: z23.string().describe("`channel_id` from the envelope of the Slack message that asked for or accepted this."),
+  confirmation_thread_ts: z23.string().describe("`thread_ts` from that message's envelope."),
+  confirmation_message_ts: z23.string().describe("`message_ts` from that message's envelope."),
+  confirmation_user_id: z23.string().describe("`user_id` from that message's envelope.")
 });
 var scoutAutomationToolInputSchema = automationToolInputSchema.extend(scoutSlackConfirmationSchema.shape);
 var scoutSaveChannelPresetToolInputSchema = scoutSlackConfirmationSchema.extend({
-  preset_id: z22.string().optional().describe(`Id of the preset to update, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`. Omit to create a new preset.`),
-  name: z22.string().trim().min(1).max(SCOUT_PRESET_NAME_MAX_LENGTH).optional().describe("Preset name. Required when creating."),
-  description: z22.string().optional().describe("One-line summary shown in settings."),
-  icon: z22.enum(SCOUT_PRESET_ICONS).optional(),
-  instructions: z22.string().optional().describe("Complete preset instructions; replaces the existing text. Required when creating.")
+  preset_id: z23.string().optional().describe(`Id of the preset to update, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`. Omit to create a new preset.`),
+  name: z23.string().trim().min(1).max(SCOUT_PRESET_NAME_MAX_LENGTH).optional().describe("Preset name. Required when creating."),
+  description: z23.string().optional().describe("One-line summary shown in settings."),
+  icon: z23.enum(SCOUT_PRESET_ICONS).optional(),
+  instructions: z23.string().optional().describe("Complete preset instructions; replaces the existing text. Required when creating.")
 });
 var scoutUpdateChannelSettingsToolInputSchema = scoutSlackConfirmationSchema.extend({
-  source: z22.enum(SCOUT_SOURCE_TYPES).optional().describe("Defaults to `slack`."),
-  external_id: z22.string().describe("Slack channel id or Linear team id."),
-  monitored: z22.boolean().optional().describe("`false` stops Scout from handling the source: it excludes a Slack channel or stops monitoring a Linear team. `true` resumes a Slack channel or starts monitoring a Linear team, and only an organization admin can ask for that. Omit to keep it."),
-  preset_id: z22.string().nullable().optional().describe("Preset to assign; `null` removes the preset. Omit to keep it."),
-  instructions: z22.string().nullable().optional().describe("Complete channel-specific instructions, applied after the preset; replaces the existing text. `null` clears them. Omit to keep them.")
+  source: z23.enum(SCOUT_SOURCE_TYPES).optional().describe("Defaults to `slack`."),
+  external_id: z23.string().describe("Slack channel id or Linear team id."),
+  monitored: z23.boolean().optional().describe("`false` stops Scout from handling the source: it excludes a Slack channel or stops monitoring a Linear team. `true` resumes a Slack channel or starts monitoring a Linear team, and only an organization admin can ask for that. Omit to keep it."),
+  preset_id: z23.string().nullable().optional().describe("Preset to assign; `null` removes the preset. Omit to keep it."),
+  instructions: z23.string().nullable().optional().describe("Complete channel-specific instructions, applied after the preset; replaces the existing text. `null` clears them. Omit to keep them.")
 });
 var scoutDeleteChannelPresetToolInputSchema = scoutSlackConfirmationSchema.extend({
-  preset_id: z22.string().describe(`Id of the preset to delete, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`.`)
+  preset_id: z23.string().describe(`Id of the preset to delete, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`.`)
 });
 
 // ../shared/src/routes/plugin-catalog.ts
@@ -9916,83 +9931,83 @@ var workspaceMarkedUnreadClientStateKey = orgUserClientStateKey(WORKSPACE_MARKED
 var promptHistoryClientStateKey = orgUserClientStateKey(PROMPT_HISTORY_CLIENT_STATE_KEY_PREFIX);
 
 // ../shared/src/routes/workspace-events.ts
-import { z as z23 } from "zod";
+import { z as z24 } from "zod";
 
 // ../shared/src/workspace-attention.ts
 var WORKSPACE_ATTENTION_REASONS = ["question", "blocked"];
 
 // ../shared/src/routes/workspace-events.ts
-var workspaceChangedEventSchema = z23.discriminatedUnion("type", [
-  z23.object({
-    type: z23.literal("workspace.changed"),
-    workspaceId: z23.string(),
-    workspace: z23.object({ status: z23.enum(WORKSPACE_STATUSES), last_activity_at: z23.string().nullable() }).optional(),
-    completion: z23.object({
-      workspaceName: z23.string(),
-      completedAt: z23.string(),
-      processing: z23.boolean().optional(),
-      attention: z23.object({ reason: z23.enum(WORKSPACE_ATTENTION_REASONS), userId: z23.string() }).optional()
+var workspaceChangedEventSchema = z24.discriminatedUnion("type", [
+  z24.object({
+    type: z24.literal("workspace.changed"),
+    workspaceId: z24.string(),
+    workspace: z24.object({ status: z24.enum(WORKSPACE_STATUSES), last_activity_at: z24.string().nullable() }).optional(),
+    completion: z24.object({
+      workspaceName: z24.string(),
+      completedAt: z24.string(),
+      processing: z24.boolean().optional(),
+      attention: z24.object({ reason: z24.enum(WORKSPACE_ATTENTION_REASONS), userId: z24.string() }).optional()
     }).optional(),
-    ts: z23.string()
+    ts: z24.string()
   }),
-  z23.object({
-    type: z23.literal("workspace.chat.changed"),
-    workspaceId: z23.string(),
-    chatId: z23.string(),
-    ts: z23.string()
+  z24.object({
+    type: z24.literal("workspace.chat.changed"),
+    workspaceId: z24.string(),
+    chatId: z24.string(),
+    ts: z24.string()
   }),
-  z23.object({
-    type: z23.literal("workspace.chat.advanced"),
-    workspaceId: z23.string(),
-    chatId: z23.string(),
-    afterCursor: z23.string().optional(),
-    processing: z23.boolean(),
-    ts: z23.string()
+  z24.object({
+    type: z24.literal("workspace.chat.advanced"),
+    workspaceId: z24.string(),
+    chatId: z24.string(),
+    afterCursor: z24.string().optional(),
+    processing: z24.boolean(),
+    ts: z24.string()
   }),
-  z23.object({ type: z23.literal("presence.changed"), ts: z23.string() }),
-  z23.object({
-    type: z23.literal("mobile-testing.changed"),
-    workspaceId: z23.string(),
-    ts: z23.string()
+  z24.object({ type: z24.literal("presence.changed"), ts: z24.string() }),
+  z24.object({
+    type: z24.literal("mobile-testing.changed"),
+    workspaceId: z24.string(),
+    ts: z24.string()
   }),
-  z23.object({
-    type: z23.literal("variable-request.changed"),
-    workspaceId: z23.string(),
-    ts: z23.string()
+  z24.object({
+    type: z24.literal("variable-request.changed"),
+    workspaceId: z24.string(),
+    ts: z24.string()
   }),
-  z23.object({
-    type: z23.literal("pull-request.changed"),
-    prUrl: z23.string(),
-    ts: z23.string()
+  z24.object({
+    type: z24.literal("pull-request.changed"),
+    prUrl: z24.string(),
+    ts: z24.string()
   }),
-  z23.object({
-    type: z23.literal("mothership.subagent.changed"),
-    workspaceId: z23.string(),
-    subagent: z23.object({ id: z23.string(), name: z23.string(), prUrl: z23.string().nullable() }),
-    ts: z23.string()
+  z24.object({
+    type: z24.literal("mothership.subagent.changed"),
+    workspaceId: z24.string(),
+    subagent: z24.object({ id: z24.string(), name: z24.string(), prUrl: z24.string().nullable() }),
+    ts: z24.string()
   })
 ]);
 
 // ../shared/src/routes/presence.ts
-import { z as z24 } from "zod";
-var presenceStatusSchema = z24.enum(["online", "typing"]);
-var presenceLocationSchema = z24.object({
-  workspaceId: z24.string().optional()
+import { z as z25 } from "zod";
+var presenceStatusSchema = z25.enum(["online", "typing"]);
+var presenceLocationSchema = z25.object({
+  workspaceId: z25.string().optional()
 });
-var presenceEntrySchema = z24.object({
-  userId: z24.string(),
+var presenceEntrySchema = z25.object({
+  userId: z25.string(),
   status: presenceStatusSchema,
   location: presenceLocationSchema,
-  ts: z24.string()
+  ts: z25.string()
 });
-var updatePresenceRequestSchema = z24.object({
+var updatePresenceRequestSchema = z25.object({
   status: presenceStatusSchema,
   location: presenceLocationSchema.optional()
 });
 
 // ../shared/src/routes/review-messages.ts
-import { z as z25 } from "zod";
-var sendPullRequestReviewMessageRequestSchema = z25.object({
+import { z as z26 } from "zod";
+var sendPullRequestReviewMessageRequestSchema = z26.object({
   ...sendChatMessageRequestSchema.pick({
     message: true,
     messageId: true,
@@ -10005,8 +10020,8 @@ var sendPullRequestReviewMessageRequestSchema = z25.object({
     ultrafastMode: true
   }).shape,
   /** Starts a new chat instead of continuing the PR's review chat. The provider only applies to a new chat. */
-  newChat: z25.boolean().optional(),
-  provider: z25.enum(VALID_AGENT_PROVIDERS).optional()
+  newChat: z26.boolean().optional(),
+  provider: z26.enum(VALID_AGENT_PROVIDERS).optional()
 });
 
 // ../shared/src/audit-log.ts
@@ -10222,30 +10237,30 @@ function isSkillRegistryManifest(value) {
 }
 
 // ../shared/src/routes/variable-requests.ts
-import { z as z26 } from "zod";
+import { z as z27 } from "zod";
 var VARIABLE_REQUEST_WAIT = { defaultMs: 10 * 6e4, maxMs: 30 * 6e4, pollMs: 3e3, waiterStaleMs: 15e3 };
 var VARIABLE_REQUEST_DESTINATIONS = ["environment", "workspace"];
-var requestedVariableSchema = z26.object({
-  key: z26.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(ENVIRONMENT_SETUP_LIMITS.variableKeyChars),
-  required: z26.boolean(),
-  replace: z26.boolean().optional()
+var requestedVariableSchema = z27.object({
+  key: z27.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(ENVIRONMENT_SETUP_LIMITS.variableKeyChars),
+  required: z27.boolean(),
+  replace: z27.boolean().optional()
 });
-var requestedVariablesSchema = z26.array(requestedVariableSchema).min(1, "must not be empty").max(ENVIRONMENT_SETUP_LIMITS.variables).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys");
-var createVariableRequestSchema = z26.object({
+var requestedVariablesSchema = z27.array(requestedVariableSchema).min(1, "must not be empty").max(ENVIRONMENT_SETUP_LIMITS.variables).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys");
+var createVariableRequestSchema = z27.object({
   variables: requestedVariablesSchema,
-  reason: z26.string().trim().max(500).nullish().transform((value) => value || null),
-  wait: z26.boolean().default(true)
+  reason: z27.string().trim().max(500).nullish().transform((value) => value || null),
+  wait: z27.boolean().default(true)
 });
-var respondVariableRequestSchema = z26.discriminatedUnion("action", [
-  z26.object({
-    action: z26.literal("provide"),
-    destination: z26.enum(VARIABLE_REQUEST_DESTINATIONS),
+var respondVariableRequestSchema = z27.discriminatedUnion("action", [
+  z27.object({
+    action: z27.literal("provide"),
+    destination: z27.enum(VARIABLE_REQUEST_DESTINATIONS),
     /** Defaults to the workspace's environment, so older clients keep saving there. */
-    environment_ids: z26.array(z26.string().uuid()).optional(),
-    overwrite: z26.boolean().optional(),
-    values: z26.record(z26.string().regex(VARIABLE_KEY_RE), z26.string())
+    environment_ids: z27.array(z27.string().uuid()).optional(),
+    overwrite: z27.boolean().optional(),
+    values: z27.record(z27.string().regex(VARIABLE_KEY_RE), z27.string())
   }),
-  z26.object({ action: z26.literal("skip") })
+  z27.object({ action: z27.literal("skip") })
 ]);
 
 export {
@@ -10403,6 +10418,8 @@ export {
   workspaceTokenResponseSchema,
   legacyWorkspaceTokenBundleSchema,
   engineMcpOAuthTokenResponseSchema,
+  SUBAGENT_SERVICE_TIERS,
+  serviceTierRequestFields,
   TERMINAL_RTC_ICE_SERVER,
   HISTORY_ROOT,
   HISTORY_INDEX_FILENAME,