replicas-engine 0.1.1024 → 0.1.1026

package/dist/src/{chunk-HHYJ2FOD.js → chunk-HLUAG4YU.js}

@@ -58,11 +58,11 @@ var CODEX_REASONING_EFFORT_BY_THINKING_LEVEL = {
   ultra: "ultra",
   ultracode: "xhigh"
 };
-function codexReasoningEffortForThinkingLevel(thinkingLevel) {
-  return thinkingLevel ? CODEX_REASONING_EFFORT_BY_THINKING_LEVEL[thinkingLevel] : void 0;
+function codexReasoningEffortForThinkingLevel(thinkingLevel2) {
+  return thinkingLevel2 ? CODEX_REASONING_EFFORT_BY_THINKING_LEVEL[thinkingLevel2] : void 0;
 }
-function getProviderDisplayName(provider, variant = "short") {
-  switch (provider) {
+function getProviderDisplayName(provider2, variant = "short") {
+  switch (provider2) {
     case "codex":
       return "Codex";
     case "cursor":
@@ -141,10 +141,10 @@ var OPENCODE_GO_BASE_URL = "https://opencode.ai/zen/go/v1";
 var DEFAULT_OPENCODE_GO_MODEL = "glm-5.3";
 async function fetchOpenCodeGoCatalog(fallbackModelIds = [DEFAULT_OPENCODE_GO_MODEL]) {
   try {
-    const provider = (await fetchModelsDevCatalog())[OPENCODE_GO_PROVIDER];
-    if (!provider) throw new Error("OpenCode Go model catalog is unavailable");
+    const provider2 = (await fetchModelsDevCatalog())[OPENCODE_GO_PROVIDER];
+    if (!provider2) throw new Error("OpenCode Go model catalog is unavailable");
     const models = Object.fromEntries(
-      Object.entries(provider.models).filter(([, definition]) => definition.status !== "deprecated" && definition.status !== "alpha").map(([id, definition]) => [id, {
+      Object.entries(provider2.models).filter(([, definition]) => definition.status !== "deprecated" && definition.status !== "alpha").map(([id, definition]) => [id, {
         id: definition.id ?? id,
         name: definition.name,
         api: definition.provider?.npm === "@ai-sdk/anthropic" ? "anthropic-messages" : definition.provider?.npm === "@ai-sdk/openai" ? "openai-responses" : void 0,
@@ -234,34 +234,34 @@ var FALLBACK_AGENT_MODEL = {
   opencode: DEFAULT_OPENCODE_MODEL,
   pi: DEFAULT_PI_MODEL
 };
-function getDefaultAgentModel(provider, overrides) {
-  const catalogDefault = overrides?.defaultModels?.[provider];
+function getDefaultAgentModel(provider2, overrides) {
+  const catalogDefault = overrides?.defaultModels?.[provider2];
   if (catalogDefault === null) return "";
-  const options = getAgentModelOptions(provider, overrides);
+  const options = getAgentModelOptions(provider2, overrides);
   if (catalogDefault && options.includes(catalogDefault)) return catalogDefault;
-  const fallback = FALLBACK_AGENT_MODEL[provider];
+  const fallback = FALLBACK_AGENT_MODEL[provider2];
   return options.includes(fallback) ? fallback : options[0] ?? "";
 }
-function normalizeClaudeModel(model) {
-  if (model === "opus" || model === CLAUDE_OPUS_1M_MODEL || model === LEGACY_CLAUDE_OPUS_1M_MODEL) {
+function normalizeClaudeModel(model2) {
+  if (model2 === "opus" || model2 === CLAUDE_OPUS_1M_MODEL || model2 === LEGACY_CLAUDE_OPUS_1M_MODEL) {
     return DEFAULT_CLAUDE_MODEL;
   }
-  if (model === "fable") {
+  if (model2 === "fable") {
     return CLAUDE_FABLE_5_1_MODEL;
   }
-  if (model === "sonnet") {
+  if (model2 === "sonnet") {
     return CLAUDE_SONNET_5_MODEL;
   }
-  if (model === "haiku") {
+  if (model2 === "haiku") {
     return CLAUDE_HAIKU_4_5_MODEL;
   }
-  return model;
+  return model2;
 }
-function toClaudeCodeModel(model, bedrock) {
+function toClaudeCodeModel(model2, bedrock) {
   if (!bedrock) {
-    return model;
+    return model2;
   }
-  switch (normalizeClaudeModel(model)) {
+  switch (normalizeClaudeModel(model2)) {
     case CLAUDE_FABLE_5_1_MODEL:
       return CLAUDE_FABLE_5_1_BEDROCK_MODEL;
     case CLAUDE_FABLE_5_MODEL:
@@ -281,7 +281,7 @@ function toClaudeCodeModel(model, bedrock) {
     case CLAUDE_HAIKU_4_5_MODEL:
       return "haiku";
     default:
-      return model;
+      return model2;
   }
 }
 var CLAUDE_MODEL_CONTEXT_WINDOWS = {
@@ -309,14 +309,14 @@ var CLAUDE_MODEL_CONTEXT_WINDOWS = {
   "claude-haiku-4-5-20251001": 2e5,
   "claude-haiku-4-5@20251001": 2e5
 };
-function getClaudeModelContextWindow(model) {
-  if (!model) return null;
-  const normalized = normalizeClaudeModel(model) ?? model;
-  return CLAUDE_MODEL_CONTEXT_WINDOWS[normalized] ?? CLAUDE_MODEL_CONTEXT_WINDOWS[model] ?? null;
+function getClaudeModelContextWindow(model2) {
+  if (!model2) return null;
+  const normalized = normalizeClaudeModel(model2) ?? model2;
+  return CLAUDE_MODEL_CONTEXT_WINDOWS[normalized] ?? CLAUDE_MODEL_CONTEXT_WINDOWS[model2] ?? null;
 }
-function canUseClaudeFastMode(model) {
-  const normalized = normalizeClaudeModel(model);
-  return normalized === CLAUDE_OPUS_5_5_MODEL || normalized === CLAUDE_OPUS_5_MODEL || normalized === CLAUDE_OPUS_4_8_MODEL || model === "claude-opus-4-7";
+function canUseClaudeFastMode(model2) {
+  const normalized = normalizeClaudeModel(model2);
+  return normalized === CLAUDE_OPUS_5_5_MODEL || normalized === CLAUDE_OPUS_5_MODEL || normalized === CLAUDE_OPUS_4_8_MODEL || model2 === "claude-opus-4-7";
 }
 var CLAUDE_MODEL_MIN_SANDBOX_IMAGE = {
   [CLAUDE_FABLE_5_1_MODEL]: "replicas-sandbox-2026-09-01-v6",
@@ -410,18 +410,18 @@ var HIDDEN_BY_DEFAULT_MODELS = /* @__PURE__ */ new Set([
   "grok-4.3",
   "kimi-k2.5"
 ]);
-var withoutHiddenByDefault = (models) => models.filter((model) => !HIDDEN_BY_DEFAULT_MODELS.has(model));
+var withoutHiddenByDefault = (models) => models.filter((model2) => !HIDDEN_BY_DEFAULT_MODELS.has(model2));
 var DEFAULT_STATIC_AGENT_MODELS = {
   claude: withoutHiddenByDefault(AGENT_MODELS.claude),
   codex: withoutHiddenByDefault(AGENT_MODELS.codex)
 };
 var DEFAULT_CURSOR_MODELS = withoutHiddenByDefault(AGENT_MODELS.cursor);
-function getAgentModelOptions(provider, overrides) {
-  const override = overrides?.[provider];
+function getAgentModelOptions(provider2, overrides) {
+  const override = overrides?.[provider2];
   if (override?.length) return override;
-  if (provider === "claude" || provider === "codex") return DEFAULT_STATIC_AGENT_MODELS[provider];
-  if (provider === "cursor") return DEFAULT_CURSOR_MODELS;
-  return AGENT_MODELS[provider] ?? [];
+  if (provider2 === "claude" || provider2 === "codex") return DEFAULT_STATIC_AGENT_MODELS[provider2];
+  if (provider2 === "cursor") return DEFAULT_CURSOR_MODELS;
+  return AGENT_MODELS[provider2] ?? [];
 }
 var SANDBOX_IMAGE_MODEL_FALLBACKS = {
   [CLAUDE_OPUS_5_5_MODEL]: CLAUDE_OPUS_5_MODEL,
@@ -629,14 +629,14 @@ var CONTEXT_WINDOW_KEYS = /* @__PURE__ */ new Set([
   "maxContextLength"
 ]);
 var MAX_CATALOG_PAGES = 20;
-function getModelContextWindow(model) {
-  const directValues = Object.entries(model).flatMap(([key, value]) => {
+function getModelContextWindow(model2) {
+  const directValues = Object.entries(model2).flatMap(([key, value]) => {
     const contextWindow = CONTEXT_WINDOW_KEYS.has(key) ? positiveInteger(value) : null;
     return contextWindow === null ? [] : [contextWindow];
   });
   if (directValues.length > 0) return Math.max(...directValues);
   const values = [];
-  const pending = Object.entries(model).filter(([key]) => !CONTEXT_WINDOW_KEYS.has(key)).map(([, value]) => value);
+  const pending = Object.entries(model2).filter(([key]) => !CONTEXT_WINDOW_KEYS.has(key)).map(([, value]) => value);
   for (let inspected = 0; pending.length > 0 && inspected < 1e3; inspected += 1) {
     const current = pending.pop();
     if (Array.isArray(current)) {
@@ -695,7 +695,7 @@ async function listOpenAICompatibleModels(credential) {
     });
     if (!response.ok) throw new Error(`Models request failed with status ${response.status}`);
     const payload = await response.json();
-    for (const model of parseOpenAICompatibleModels(payload)) models.set(model.id, model);
+    for (const model2 of parseOpenAICompatibleModels(payload)) models.set(model2.id, model2);
     if (!isRecord(payload) || payload.has_more !== true) break;
     if (page === MAX_CATALOG_PAGES - 1) throw new Error(`The models endpoint exceeded ${MAX_CATALOG_PAGES} pages`);
     if (typeof payload.next_cursor !== "string" || !payload.next_cursor) {
@@ -732,17 +732,17 @@ function readOllamaAuthEnv(agent, env) {
 var DEFAULT_OLLAMA_MODEL = "gpt-oss:20b";
 var catalogs = /* @__PURE__ */ new Map();
 function getDefaultOllamaModel(models) {
-  return models.find((model) => model.id === DEFAULT_OLLAMA_MODEL && model.capabilities?.includes("tools") && (model.contextWindow ?? 0) >= 64e3)?.id ?? null;
+  return models.find((model2) => model2.id === DEFAULT_OLLAMA_MODEL && model2.capabilities?.includes("tools") && (model2.contextWindow ?? 0) >= 64e3)?.id ?? null;
 }
-function parseOllamaModelDetails(model, payload) {
-  if (!isRecord(payload)) return model;
+function parseOllamaModelDetails(model2, payload) {
+  if (!isRecord(payload)) return model2;
   const capabilities = Array.isArray(payload.capabilities) ? payload.capabilities.filter((value) => typeof value === "string") : void 0;
   const info = isRecord(payload.model_info) ? payload.model_info : {};
   const context = Object.entries(info).find(([key]) => key.endsWith(".context_length"))?.[1];
   const configured = typeof payload.parameters === "string" ? /(?:^|\n)\s*num_ctx\s+(\d+)/.exec(payload.parameters)?.[1] : void 0;
   const contextWindow = configured ? Number(configured) : context;
   return {
-    ...model,
+    ...model2,
     ...capabilities ? { capabilities } : {},
     ...typeof contextWindow === "number" && Number.isSafeInteger(contextWindow) && contextWindow > 0 ? { contextWindow } : {}
   };
@@ -769,18 +769,18 @@ async function loadOllamaModels(credential) {
       detailed.push(...models.slice(offset));
       break;
     }
-    detailed.push(...await Promise.all(models.slice(offset, offset + 10).map(async (model) => {
+    detailed.push(...await Promise.all(models.slice(offset, offset + 10).map(async (model2) => {
       try {
         const response = await fetch(url, {
           method: "POST",
           redirect: "error",
           signal,
           headers: { Authorization: `Bearer ${credential.apiKey}`, "Content-Type": "application/json" },
-          body: JSON.stringify({ model: model.id })
+          body: JSON.stringify({ model: model2.id })
         });
-        return response.ok ? parseOllamaModelDetails(model, await response.json()) : model;
+        return response.ok ? parseOllamaModelDetails(model2, await response.json()) : model2;
       } catch {
-        return model;
+        return model2;
       }
     })));
   }
@@ -1030,6 +1030,7 @@ function isCredentialScope(value) {
 function isAgentChatTurnActivityRecord(value) {
   return isAgentChatActivityRecord(value) && typeof value.turnId === "string" && typeof value.seconds === "number" && Number.isFinite(value.seconds) && value.seconds >= 0;
 }
+var SKILL_USE_KINDS = ["invoke", "read", "shell"];
 function isAgentChatActivityCallRecord(value) {
   return isAgentChatActivityRecord(value) && typeof value.callId === "string" && value.callId.length > 0;
 }
@@ -1039,7 +1040,7 @@ function isNamedAgentChatActivityRecord(value, field) {
   return typeof name === "string" && name.length > 0;
 }
 function isAgentChatSkillActivityRecord(value) {
-  return isNamedAgentChatActivityRecord(value, "skillName");
+  return isNamedAgentChatActivityRecord(value, "skillName") && isRecord(value) && (value.useKind === void 0 || SKILL_USE_KINDS.some((kind) => kind === value.useKind));
 }
 function isAgentChatMcpActivityRecord(value) {
   return isNamedAgentChatActivityRecord(value, "mcpName");
@@ -1101,14 +1102,14 @@ var AUTH_RETRY_STATUS_EVENT_TYPE = "auth-retry-status";
 var CURSOR_CONNECTION_STATUS_EVENT_TYPE = "cursor-connection-status";
 var AUTH_FALLBACK_EVENT_TYPE = "auth-fallback";
 function coerceAuthFallbackPayload(payload) {
-  const { provider, reason, exhaustedMethod, exhaustedScope, candidateMethod, candidateScope, status, detail } = payload;
+  const { provider: provider2, reason, exhaustedMethod, exhaustedScope, candidateMethod, candidateScope, status, detail } = payload;
   const exhaustedAccount = credentialAccountSchema.safeParse(payload.exhaustedAccount).data;
   const candidateAccount = credentialAccountSchema.safeParse(payload.candidateAccount).data;
-  if (typeof provider !== "string" || !isValidAgentProvider(provider) || reason !== "rate_limit" && reason !== "out_of_credits" || !isAuthMethod(exhaustedMethod) || !isAuthMethod(candidateMethod) || !isCredentialScope(candidateScope) || status !== "switched" && status !== "failed") {
+  if (typeof provider2 !== "string" || !isValidAgentProvider(provider2) || reason !== "rate_limit" && reason !== "out_of_credits" || !isAuthMethod(exhaustedMethod) || !isAuthMethod(candidateMethod) || !isCredentialScope(candidateScope) || status !== "switched" && status !== "failed") {
     return null;
   }
   return {
-    provider,
+    provider: provider2,
     reason,
     exhaustedMethod,
     ...isCredentialScope(exhaustedScope) ? { exhaustedScope } : {},
@@ -1279,14 +1280,14 @@ function imageContentToUserMessageImages(images) {
   }
   return userImages.length > 0 ? userImages : void 0;
 }
-function createAcceptedUserMessageEvent(message, messageId, timestamp, images) {
+function createAcceptedUserMessageEvent(message2, messageId, timestamp, images) {
   const eventImages = imageContentToUserMessageImages(images);
   return {
     timestamp,
     type: "event_msg",
     payload: {
       type: "user_message",
-      message,
+      message: message2,
       source: ACCEPTED_USER_MESSAGE_SOURCE,
       [USER_MESSAGE_ID_PAYLOAD_KEY]: messageId,
       ...eventImages ? { images: eventImages } : {}
@@ -1492,6 +1493,62 @@ function paginateChatHistory(full, params) {
   };
 }
 
+// ../shared/src/subagent-mcp.ts
+var SUBAGENT_MCP_SERVER_NAME = "subagents";
+var SUBAGENT_MCP_TOOLS = {
+  getProviders: "get_providers",
+  spawnAgent: "spawn_agent",
+  getAgent: "get_agent",
+  waitAgent: "wait_agent",
+  messageAgent: "message_agent",
+  deleteAgent: "delete_agent"
+};
+var SUBAGENT_MCP_TOOL_NAMES = Object.values(SUBAGENT_MCP_TOOLS);
+
+// ../shared/src/workspace-identity.ts
+import { z as z4 } from "zod";
+var WORKSPACE_IDENTITY_AUDIENCE = "replicas:workspace";
+var AWS_SOURCE_IDENTITY_CLAIM = "https://aws.amazon.com/source_identity";
+var WORKSPACE_TOKEN_TTL_SECONDS = 15 * 60;
+var IDENTITY_PROXY_PORT = 17323;
+var IDENTITY_TOKEN_PATH = "/token";
+var workspaceAudienceSchema = z4.string().min(1).max(255).regex(/^[\x21-\x7e]+$/, "Audience must be a single printable token without spaces");
+var workspaceTokenRequestSchema = z4.object({
+  audience: workspaceAudienceSchema.optional(),
+  aws_source_identity: z4.boolean().optional()
+});
+var workspaceTokenClaimsSchema = z4.object({
+  iss: z4.string(),
+  sub: z4.string(),
+  aud: z4.string(),
+  iat: z4.number().int(),
+  nbf: z4.number().int(),
+  exp: z4.number().int(),
+  jti: z4.string(),
+  organization_id: z4.string().uuid(),
+  workspace_id: z4.string().uuid(),
+  environment_id: z4.string().uuid(),
+  creator_id: z4.string().uuid().nullable(),
+  creator_email: z4.string().nullable().default(null),
+  [AWS_SOURCE_IDENTITY_CLAIM]: z4.string().uuid().optional()
+}).passthrough();
+var workspaceTokenResponseSchema = z4.object({
+  issuer: z4.string(),
+  audience: z4.string(),
+  token: z4.string(),
+  expires_at: z4.string()
+});
+var legacyWorkspaceTokenBundleSchema = z4.object({
+  version: z4.literal(1),
+  issuer: z4.string(),
+  default_audience: z4.string(),
+  tokens: z4.record(z4.string(), z4.object({ token: z4.string(), expires_at: z4.string() }))
+});
+var mcpWorkloadAuthSchema = z4.strictObject({
+  type: z4.literal("workspace_identity"),
+  audience: workspaceAudienceSchema
+});
+
 // ../shared/src/runtime-env.ts
 var REPLICAS_RUNTIME_ENV_ALIASES = {
   monolithUrl: ["REPLICAS_MONOLITH_URL", "MONOLITH_URL"],
@@ -1694,80 +1751,24 @@ function gitIdentityConfigCommands(identity, scope = "global") {
   ];
 }
 
-// ../shared/src/subagent-mcp.ts
-var SUBAGENT_MCP_SERVER_NAME = "subagents";
-var SUBAGENT_MCP_TOOLS = {
-  getProviders: "get_providers",
-  spawnAgent: "spawn_agent",
-  getAgent: "get_agent",
-  waitAgent: "wait_agent",
-  messageAgent: "message_agent",
-  deleteAgent: "delete_agent"
-};
-var SUBAGENT_MCP_TOOL_NAMES = Object.values(SUBAGENT_MCP_TOOLS);
-
 // ../shared/src/headless-agent.ts
-import { z as z4 } from "zod";
-var headlessAgentRequestSchema = z4.object({
-  mode: z4.literal("structured"),
-  agent: z4.custom(
+import { z as z5 } from "zod";
+var headlessAgentRequestSchema = z5.object({
+  mode: z5.literal("structured"),
+  agent: z5.custom(
     (value) => typeof value === "string" && isValidAgentProvider(value)
   ),
-  model: z4.string().min(1),
-  prompt: z4.string(),
-  workingDirectory: z4.string().min(1),
-  timeoutSeconds: z4.number().int().min(1).max(1800).default(300),
-  codexOauthTokens: z4.object({ accessToken: z4.string(), accountId: z4.string() }).optional(),
-  outputSchema: z4.record(z4.string(), z4.json())
+  model: z5.string().min(1),
+  prompt: z5.string(),
+  workingDirectory: z5.string().min(1),
+  timeoutSeconds: z5.number().int().min(1).max(1800).default(300),
+  codexOauthTokens: z5.object({ accessToken: z5.string(), accountId: z5.string() }).optional(),
+  outputSchema: z5.record(z5.string(), z5.json())
 });
 
 // ../shared/src/engine/environment.ts
 var DESKTOP_STREAM_PORT = 6080;
 
-// ../shared/src/workspace-identity.ts
-import { z as z5 } from "zod";
-var WORKSPACE_IDENTITY_AUDIENCE = "replicas:workspace";
-var AWS_SOURCE_IDENTITY_CLAIM = "https://aws.amazon.com/source_identity";
-var WORKSPACE_TOKEN_TTL_SECONDS = 15 * 60;
-var IDENTITY_PROXY_PORT = 17323;
-var IDENTITY_TOKEN_PATH = "/token";
-var workspaceAudienceSchema = z5.string().min(1).max(255).regex(/^[\x21-\x7e]+$/, "Audience must be a single printable token without spaces");
-var workspaceTokenRequestSchema = z5.object({
-  audience: workspaceAudienceSchema.optional(),
-  aws_source_identity: z5.boolean().optional()
-});
-var workspaceTokenClaimsSchema = z5.object({
-  iss: z5.string(),
-  sub: z5.string(),
-  aud: z5.string(),
-  iat: z5.number().int(),
-  nbf: z5.number().int(),
-  exp: z5.number().int(),
-  jti: z5.string(),
-  organization_id: z5.string().uuid(),
-  workspace_id: z5.string().uuid(),
-  environment_id: z5.string().uuid(),
-  creator_id: z5.string().uuid().nullable(),
-  creator_email: z5.string().nullable().default(null),
-  [AWS_SOURCE_IDENTITY_CLAIM]: z5.string().uuid().optional()
-}).passthrough();
-var workspaceTokenResponseSchema = z5.object({
-  issuer: z5.string(),
-  audience: z5.string(),
-  token: z5.string(),
-  expires_at: z5.string()
-});
-var legacyWorkspaceTokenBundleSchema = z5.object({
-  version: z5.literal(1),
-  issuer: z5.string(),
-  default_audience: z5.string(),
-  tokens: z5.record(z5.string(), z5.object({ token: z5.string(), expires_at: z5.string() }))
-});
-var mcpWorkloadAuthSchema = z5.strictObject({
-  type: z5.literal("workspace_identity"),
-  audience: workspaceAudienceSchema
-});
-
 // ../shared/src/sse.ts
 function parseSseChunk(chunk) {
   let data = "";
@@ -1828,10 +1829,10 @@ async function raceWithTimeout(promise, ms) {
     });
   }
 }
-async function withTimeout(promise, ms, message) {
+async function withTimeout(promise, ms, message2) {
   const result = await raceWithTimeout(promise, ms);
   if (result === TIMEOUT) {
-    throw new Error(message);
+    throw new Error(message2);
   }
   return result;
 }
@@ -1863,9 +1864,9 @@ function detectAgentQuotaLimit(text2) {
 }
 
 // ../shared/src/auth-fallback.ts
-function describeCredential(provider, credential) {
+function describeCredential(provider2, credential) {
   const { ownerName, email, ordinal } = credential.account ?? {};
-  const label = `${getCredentialMethodLabel(provider, credential.method)}${ordinal ? ` #${ordinal}` : ""}`;
+  const label = `${getCredentialMethodLabel(provider2, credential.method)}${ordinal ? ` #${ordinal}` : ""}`;
   const owner = credential.scope === CREDENTIAL_SCOPE.USER ? ownerName ? `${ownerName}'s personal ${label}` : `your ${label}` : credential.scope === CREDENTIAL_SCOPE.ORG ? `the organization's ${label}` : `the ${label}`;
   return email ? `${owner} (${email})` : owner;
 }
@@ -1894,12 +1895,12 @@ var workspaceCredentialProviderSchema = z6.enum(WORKSPACE_CREDENTIAL_PROVIDERS);
 var workspaceCredentialSelectionSchema = agentCredentialSnapshotSchema.omit({ revision: true, account: true, credentialId: true });
 var createWorkspaceCredentialSchema = workspaceCredentialSelectionSchema.extend({
   provider: z6.enum(VALID_AGENT_PROVIDERS)
-}).refine(({ provider, method }) => agentCredentialMethods(provider).includes(method), {
+}).refine(({ provider: provider2, method }) => agentCredentialMethods(provider2).includes(method), {
   message: "This inference provider is not supported by this agent"
 });
 var switchWorkspaceCredentialSchema = workspaceCredentialSelectionSchema.extend({
   provider: workspaceCredentialProviderSchema
-}).refine(({ provider, method }) => agentCredentialMethods(provider).includes(method), {
+}).refine(({ provider: provider2, method }) => agentCredentialMethods(provider2).includes(method), {
   message: "This authentication method is not supported by this agent"
 });
 
@@ -1961,8 +1962,8 @@ var forkChatRequestSchema = z8.object({
 function describeQuotaLimit(reason) {
   return reason === "out_of_credits" ? "ran out of credits" : "hit its usage limit";
 }
-function describeChatForkReason(reason, provider) {
-  return reason ? `${getProviderDisplayName(provider)} ${describeQuotaLimit(reason)}` : null;
+function describeChatForkReason(reason, provider2) {
+  return reason ? `${getProviderDisplayName(provider2)} ${describeQuotaLimit(reason)}` : null;
 }
 var AGENT_QUOTA_EXHAUSTED_EVENT_TYPE = "agent-quota-exhausted";
 var agentQuotaExhaustedPayloadSchema = z8.object({
@@ -1971,8 +1972,8 @@ var agentQuotaExhaustedPayloadSchema = z8.object({
   detail: z8.string().optional(),
   forkTo: fallbackHarnessStepSchema.optional()
 });
-function defaultForkChatTitle(source, provider) {
-  return isDefaultChat(source) ? `Forked from ${source.title}` : `${source.title} (${getProviderDisplayName(provider)})`;
+function defaultForkChatTitle(source, provider2) {
+  return isDefaultChat(source) ? `Forked from ${source.title}` : `${source.title} (${getProviderDisplayName(provider2)})`;
 }
 
 // ../shared/src/credential-pool.ts
@@ -2183,6 +2184,7 @@ function emit(scope, raw) {
     stdin,
     afterAnd: raw.afterAnd,
     stdinFile: stdinFile ? resolveShellPath(scope.dir, stdinFile.target) : null,
+    stdinTarget: stdinFile?.target ?? null,
     writes: raw.redirects.flatMap(({ op, target }) => /^(?:1?>|1?>\||1?>>|&>|&>>|>&)$/.test(op) && !/^(?:\d+|-)$/.test(target) ? [{ path: resolveShellPath(scope.dir, target), target, content: output, append: op.endsWith(">>") }] : []),
     wrapper: script !== void 0,
     truncated,
@@ -2394,13 +2396,13 @@ function stringifyDisplayValue(value) {
     return String(value);
   }
 }
-function upsertDisplayMessage(messages, message) {
-  const index = messages.findIndex((candidate) => candidate.id === message.id);
-  if (index === -1) messages.push(message);
-  else messages[index] = message;
-  return message;
+function upsertDisplayMessage(messages, message2) {
+  const index = messages.findIndex((candidate) => candidate.id === message2.id);
+  if (index === -1) messages.push(message2);
+  else messages[index] = message2;
+  return message2;
 }
-function applyToolInputEvent(event, messages, provider, state, questionFilter) {
+function applyToolInputEvent(event, messages, provider2, state, questionFilter) {
   if (event.type === "replicas-tool-input-request" && typeof event.payload.toolUseId === "string" && typeof event.payload.requestId === "string" && (Array.isArray(event.payload.options) || Array.isArray(event.payload.questions))) {
     const previous = state.resolutions.get(event.payload.toolUseId);
     const resolved = previous && (!previous.requestId || previous.requestId === event.payload.requestId) ? previous : void 0;
@@ -2413,8 +2415,8 @@ function applyToolInputEvent(event, messages, provider, state, questionFilter) {
       ...resolved?.selectionSummary ? { selectionSummary: resolved.selectionSummary } : {}
     };
     state.requests.set(event.payload.toolUseId, inputRequest);
-    const message = messages.find((candidate) => candidate.type === "tool_call" && candidate.id === `${provider}-tool-${event.payload.toolUseId}`);
-    if (message) message.inputRequest = inputRequest;
+    const message2 = messages.find((candidate) => candidate.type === "tool_call" && candidate.id === `${provider2}-tool-${event.payload.toolUseId}`);
+    if (message2) message2.inputRequest = inputRequest;
     return true;
   }
   if (event.type === "replicas-tool-input-resolved" && typeof event.payload.toolUseId === "string" && typeof event.payload.selectionId === "string") {
@@ -2445,60 +2447,47 @@ function parseSkillName(tool, input) {
   return typeof skillName === "string" && skillName ? skillName : null;
 }
 function skillNameFromFilePath(path) {
-  const skillName = skillNameFromSkillRootPath(path);
-  if (skillName) return skillName;
   const parts = path.split(/[\\/]+/).filter(Boolean);
   if (parts.length < 2 || parts[parts.length - 1].toLowerCase() !== "skill.md") return null;
-  const fallbackSkillName = parts[parts.length - 2];
-  return fallbackSkillName && fallbackSkillName.toLowerCase() !== "skills" ? fallbackSkillName : null;
+  const skillName = parts[parts.length - 2];
+  return /[*?[\]{}…$]/.test(skillName) || ["skills", ".system"].includes(skillName.toLowerCase()) ? null : skillName;
 }
-function skillNameFromSkillRootPath(path) {
-  const parts = path.split(/[\\/]+/).filter(Boolean);
-  const skillsIndex = parts.findLastIndex((part) => part.toLowerCase() === "skills");
-  if (skillsIndex === -1) return null;
-  const firstSkillPart = parts[skillsIndex + 1];
-  const skillName = firstSkillPart?.toLowerCase() === ".system" ? parts[skillsIndex + 2] : firstSkillPart;
-  return skillName && skillName.toLowerCase() !== "skill.md" ? skillName : null;
-}
-function parseSkillFilePath(input) {
+var READ_TOOL_NAMES = /* @__PURE__ */ new Set(["read", "read_file", "readfile", "view"]);
+function skillFilePath(tool, input) {
+  if (!READ_TOOL_NAMES.has(tool.toLowerCase())) return null;
   const parsedInput = typeof input === "string" ? safeJsonParse(input, null) : input;
   if (!isRecord(parsedInput)) return null;
   const path = [parsedInput.path, parsedInput.filePath, parsedInput.file_path].find((value) => typeof value === "string" && value.length > 0);
-  if (!path) return null;
-  return skillNameFromFilePath(path);
-}
-function skillNameFromToolCall(tool, input) {
-  const directSkillName = parseSkillName(tool, input);
-  if (directSkillName) return directSkillName;
-  if (typeof tool !== "string" || !["read", "read_file", "readfile"].includes(tool.toLowerCase())) return null;
-  return parseSkillFilePath(input);
-}
-function createCallDisplayMessage(message) {
-  if (message.inputRequest) return { ...message, type: "tool_call" };
-  const skillName = message.server.toLowerCase() === "skills" ? message.tool : skillNameFromToolCall(message.tool, message.input);
-  if (skillName === null) return { ...message, type: "tool_call" };
+  return path && skillNameFromFilePath(path) ? path : null;
+}
+function createCallDisplayMessage(message2) {
+  if (message2.inputRequest) return { ...message2, type: "tool_call" };
+  const path = skillFilePath(message2.tool, message2.input);
+  const skillName = message2.server.toLowerCase() === "skills" ? message2.tool : path ? skillNameFromFilePath(path) : parseSkillName(message2.tool, message2.input);
+  if (skillName === null) return { ...message2, type: "tool_call" };
   return {
-    id: message.id,
+    id: message2.id,
     type: "skill",
     skillName,
-    status: message.status,
-    timestamp: message.timestamp
+    ...path ? { path } : {},
+    status: message2.status,
+    timestamp: message2.timestamp
   };
 }
-function insertDisplayMessageByTimestamp(messages, message) {
-  const messageMs = parseTimestampMs(message.timestamp);
+function insertDisplayMessageByTimestamp(messages, message2) {
+  const messageMs = parseTimestampMs(message2.timestamp);
   let index = messages.length;
   while (index > 0 && parseTimestampMs(messages[index - 1].timestamp) > messageMs) index--;
-  messages.splice(index, 0, message);
+  messages.splice(index, 0, message2);
 }
 
 // ../shared/src/display-message/format.ts
-function planItemsFromMessage(message) {
-  if (message.type === "todo_list") {
-    return message.items.map((item) => ({ text: item.text, status: todoItemStatus(item) }));
+function planItemsFromMessage(message2) {
+  if (message2.type === "todo_list") {
+    return message2.items.map((item) => ({ text: item.text, status: todoItemStatus(item) }));
   }
-  if (message.type !== "tool_call" || message.tool !== "TodoWrite" && message.tool !== "write_todos") return null;
-  const input = typeof message.input === "object" ? message.input : null;
+  if (message2.type !== "tool_call" || message2.tool !== "TodoWrite" && message2.tool !== "write_todos") return null;
+  const input = typeof message2.input === "object" ? message2.input : null;
   const todos = Array.isArray(input?.todos) ? input.todos : null;
   if (!todos) return null;
   return todos.flatMap((todo) => {
@@ -2512,34 +2501,34 @@ function planItemsFromMessage(message) {
 function todoItemStatus(item) {
   return item.itemStatus ?? (item.completed ? "completed" : "pending");
 }
-function getDisplayMessageActivity(message) {
-  if (message.type === "user" || message.type === "agent" || message.type === "reasoning") return null;
-  if (message.type === "command") return { kind: "command", title: "Command", summary: message.command, content: message.output ?? "" };
-  if (message.type === "patch") {
-    const operations = message.operations.map((operation) => `${operation.action.toUpperCase()} ${operation.path}${operation.moveTo ? ` \u2192 ${operation.moveTo}` : ""}${operation.diff ? `
+function getDisplayMessageActivity(message2) {
+  if (message2.type === "user" || message2.type === "agent" || message2.type === "reasoning") return null;
+  if (message2.type === "command") return { kind: "command", title: "Command", summary: message2.command, content: message2.output ?? "" };
+  if (message2.type === "patch") {
+    const operations = message2.operations.map((operation) => `${operation.action.toUpperCase()} ${operation.path}${operation.moveTo ? ` \u2192 ${operation.moveTo}` : ""}${operation.diff ? `
 ${operation.diff}` : ""}`).join("\n\n");
-    return { kind: "file", title: "Apply patch", summary: message.operations.map((operation) => operation.path).join(", "), content: [operations, message.output].filter(Boolean).join("\n\n") };
+    return { kind: "file", title: "Apply patch", summary: message2.operations.map((operation) => operation.path).join(", "), content: [operations, message2.output].filter(Boolean).join("\n\n") };
   }
-  if (message.type === "file_change") return { kind: "file", title: "File changes", summary: message.changes.map((change) => change.path).join(", "), content: message.changes.map((change) => `${change.kind.toUpperCase()} ${change.path}`).join("\n") };
-  if (message.type === "tool_call") return { kind: "tool", title: `Tool \xB7 ${message.tool}`, summary: message.server, content: [stringifyDisplayValue(message.input), message.output].filter(Boolean).join("\n\n") };
-  if (message.type === "web_search") return { kind: "search", title: "Web search", summary: message.query, content: "" };
-  if (message.type === "todo_list") {
-    const items = planItemsFromMessage(message) ?? [];
+  if (message2.type === "file_change") return { kind: "file", title: "File changes", summary: message2.changes.map((change) => change.path).join(", "), content: message2.changes.map((change) => `${change.kind.toUpperCase()} ${change.path}`).join("\n") };
+  if (message2.type === "tool_call") return { kind: "tool", title: `Tool \xB7 ${message2.tool}`, summary: message2.server, content: [stringifyDisplayValue(message2.input), message2.output].filter(Boolean).join("\n\n") };
+  if (message2.type === "web_search") return { kind: "search", title: "Web search", summary: message2.query, content: "" };
+  if (message2.type === "todo_list") {
+    const items = planItemsFromMessage(message2) ?? [];
     return { kind: "plan", title: "Plan", summary: `${items.filter((item) => item.status === "completed").length}/${items.length}`, content: "", items };
   }
-  if (message.type === "subagent") return { kind: "task", title: "Subagent", summary: message.description, content: [message.prompt, message.model ? `Model: ${message.model}` : "", message.receiverThreadIds?.length ? `Threads: ${message.receiverThreadIds.join(", ")}` : "", message.output].filter(Boolean).join("\n\n") };
-  if (message.type === "background_task") return { kind: "task", title: message.description ?? message.summary ?? "Background task", summary: message.taskType ?? "", content: [message.prompt, message.outputFile, message.error].filter(Boolean).join("\n\n") };
-  if (message.type === "skill") return { kind: "tool", title: `Skill \xB7 ${message.skillName}`, summary: message.args ?? "", content: "" };
-  if (message.type === "quota_status") {
-    const rateLimited = message.state === "rate_limited";
-    return { kind: "error", title: rateLimited ? "Codex rate limit" : "Codex credits", summary: "", content: rateLimited ? `Codex hit a rate limit${message.rateLimitResetType ? ` (${message.rateLimitResetType})` : ""} \u2014 try again after reset.` : "Codex is out of credits \u2014 top up your OpenAI account to resume." };
+  if (message2.type === "subagent") return { kind: "task", title: "Subagent", summary: message2.description, content: [message2.prompt, message2.model ? `Model: ${message2.model}` : "", message2.receiverThreadIds?.length ? `Threads: ${message2.receiverThreadIds.join(", ")}` : "", message2.output].filter(Boolean).join("\n\n") };
+  if (message2.type === "background_task") return { kind: "task", title: message2.description ?? message2.summary ?? "Background task", summary: message2.taskType ?? "", content: [message2.prompt, message2.outputFile, message2.error].filter(Boolean).join("\n\n") };
+  if (message2.type === "skill") return { kind: "tool", title: `Skill \xB7 ${message2.skillName}`, summary: message2.args ?? "", content: "" };
+  if (message2.type === "quota_status") {
+    const rateLimited = message2.state === "rate_limited";
+    return { kind: "error", title: rateLimited ? "Codex rate limit" : "Codex credits", summary: "", content: rateLimited ? `Codex hit a rate limit${message2.rateLimitResetType ? ` (${message2.rateLimitResetType})` : ""} \u2014 try again after reset.` : "Codex is out of credits \u2014 top up your OpenAI account to resume." };
   }
-  if (message.type === "auth_fallback") {
-    const { headline, outcomeClause } = describeAuthFallback(message);
-    return { kind: "error", title: "Credential fallback", summary: headline, content: [`The workspace ${outcomeClause}.`, message.detail].filter(Boolean).join("\n\n") };
+  if (message2.type === "auth_fallback") {
+    const { headline, outcomeClause } = describeAuthFallback(message2);
+    return { kind: "error", title: "Credential fallback", summary: headline, content: [`The workspace ${outcomeClause}.`, message2.detail].filter(Boolean).join("\n\n") };
   }
-  if (message.type === "interruption") return { kind: "error", title: "Agent stopped", summary: "", content: "" };
-  return { kind: "error", title: "Agent error", summary: "", content: message.message };
+  if (message2.type === "interruption") return { kind: "error", title: "Agent stopped", summary: "", content: "" };
+  return { kind: "error", title: "Agent error", summary: "", content: message2.message };
 }
 function fileContentDiff(path, content, action) {
   const lines = content.replace(/\n$/, "").split("\n");
@@ -2550,29 +2539,96 @@ function fileContentDiff(path, content, action) {
     ...lines.map((line) => `${action === "add" ? "+" : "-"}${line}`)
   ].join("\n");
 }
+var SEARCH_COMMANDS = /* @__PURE__ */ new Set(["grep", "rg"]);
+var OPTION_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-A",
+  "-B",
+  "-C",
+  "-e",
+  "-f",
+  "-m",
+  "--after-context",
+  "--before-context",
+  "--context",
+  "--glob",
+  "--max-count",
+  "--regexp"
+]);
+var LINE_COUNT_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-c",
+  "-n",
+  "--lines"
+]);
 var SCRIPT_ROOT = "/
";
 var commandName = (argv) => argv[0].split("/").pop() ?? argv[0];
 var fileWrites = ({ writes }) => writes.filter(({ path }) => path !== "/dev/null");
 function shellCommands(command) {
   return parseShellScript(command, SCRIPT_ROOT).filter(({ wrapper }) => !wrapper);
 }
-function simpleCommands(command) {
-  const commands = shellCommands(command);
-  const hasRedirectOrSubshell = commands.some((shellCommand) => shellCommand.subshell || shellCommand.stdinFile !== null || !shellCommand.piped && shellCommand.stdin !== void 0 || fileWrites(shellCommand).length > 0);
-  if (commands.length === 0 || hasRedirectOrSubshell) return null;
-  return commands.map((shellCommand) => {
-    const argv = shellCommand.argv.map((word) => word.replaceAll(SHELL_OPAQUE, "\u2026"));
-    return { ...shellCommand, argv, name: commandName(argv) };
-  });
-}
+var SKILL_READ_COMMANDS = /* @__PURE__ */ new Set(["awk", "bat", "cat", "head", "less", "more", "nl", "sed", "tail"]);
 function skillNamesFromCommand(command) {
-  const commands = simpleCommands(command);
-  if (!commands) return [];
-  return Array.from(new Set(commands.flatMap(({ argv }) => argv).flatMap((word) => {
-    const skillName = skillNameFromSkillRootPath(word);
-    return skillName ? [skillName] : [];
+  return Array.from(new Set(shellCommands(command).flatMap((shellCommand) => {
+    const argv = shellCommand.argv.map((word) => word.replaceAll(SHELL_OPAQUE, "\u2026"));
+    const name = argv[0] ? commandName(argv) : "";
+    if (!SKILL_READ_COMMANDS.has(name) || writesFiles(name, argv) || fileWrites(shellCommand).length > 0) return [];
+    const paths = readCommandPaths(name, argv);
+    const stdinTarget = shellCommand.stdinTarget?.replaceAll(SHELL_OPAQUE, "\u2026");
+    return (paths.length === 0 && stdinTarget ? [stdinTarget] : paths).flatMap((path) => {
+      const resolved = path.startsWith("~") ? path : resolveShellPath(shellCommand.dir, path)?.replace(SCRIPT_ROOT, "");
+      const skillName = resolved && skillNameFromFilePath(resolved);
+      return skillName ? [skillName] : [];
+    });
   })));
 }
+function pathArgs(words, extraValueFlags) {
+  const paths = [];
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i];
+    if (OPTION_VALUE_FLAGS.has(word) || extraValueFlags?.has(word)) {
+      i++;
+      continue;
+    }
+    if (word.startsWith("--glob=") || word.startsWith("--regexp=")) continue;
+    if (word.startsWith("-")) continue;
+    paths.push(word);
+  }
+  return Array.from(new Set(paths));
+}
+function readCommandPaths(command, words) {
+  if (SEARCH_COMMANDS.has(command)) {
+    const args = pathArgs(words.slice(1));
+    return args.slice(1);
+  }
+  if (command === "sed") {
+    const paths = [];
+    let sawScript = false;
+    for (let i = 1; i < words.length; i++) {
+      const word = words[i];
+      if (word === "-n" || word.startsWith("-n")) continue;
+      if (word === "-e" || word === "-f" || word === "--expression" || word === "--file") {
+        i++;
+        sawScript = true;
+        continue;
+      }
+      if (word.startsWith("--expression=") || word.startsWith("--file=")) {
+        sawScript = true;
+        continue;
+      }
+      if (word.startsWith("-")) continue;
+      if (!sawScript) {
+        sawScript = true;
+        continue;
+      }
+      paths.push(word);
+    }
+    return Array.from(new Set(paths));
+  }
+  return pathArgs(words.slice(1), command === "head" || command === "tail" ? LINE_COUNT_VALUE_FLAGS : void 0);
+}
+function writesFiles(name, argv) {
+  if (name === "sed") return argv.some((word) => /^(-[a-zA-Z]*i|--in-place)/.test(word));
+  return name === "find" && argv.some((word) => /^-(exec|ok|delete|fprint|fls)/.test(word));
+}
 
 // ../shared/src/user-message-matching.ts
 function parseTimestampMs(timestamp) {
@@ -2672,16 +2728,16 @@ function decodePathSegments(segments) {
     }
   });
 }
-function buildCodeHostPrUrl(repoUrl, provider, prNumber) {
+function buildCodeHostPrUrl(repoUrl, provider2, prNumber) {
   const normalizedRepoUrl = repoUrl.replace(/\.git$/, "");
-  if (provider === "gitlab") {
+  if (provider2 === "gitlab") {
     return `${normalizedRepoUrl}/-/merge_requests/${prNumber}`;
   }
   return `${normalizedRepoUrl}/pull/${prNumber}`;
 }
 
 // ../shared/src/replicas-mcp.ts
-import { z as z11 } from "zod";
+import { z as z14 } from "zod";
 
 // ../shared/src/automations/trigger-schemas.ts
 import { z as z10 } from "zod";
@@ -2711,32 +2767,22 @@ var automationTriggerSchema = z10.discriminatedUnion("type", [
   z10.object({ type: z10.literal("custom"), config: z10.object({}) })
 ]);
 
-// ../shared/src/replicas-mcp.ts
-var REPLICAS_MCP_TOOLS = {
-  listEnvironments: "list_environments",
-  createAutomation: "create_automation",
-  spawn: "spawn_workspace",
-  relay: "relay_to_workspace",
-  linearStart: "start_linear_session",
-  linearSessionIntent: "register_linear_session_intent",
-  listChannelSettings: "list_channel_settings",
-  saveChannelPreset: "save_channel_preset",
-  updateChannelSettings: "update_channel_settings",
-  spawnSubagent: "spawn_subagent",
-  messageSubagent: "message_subagent",
-  listSubagents: "list_subagents",
-  readSubagent: "read_subagent",
-  archiveSubagent: "archive_subagent"
-};
-var automationToolInputSchema = z11.object({
-  name: z11.string().describe("Short automation name."),
-  prompt: z11.string().describe("Prompt each automation run starts with."),
-  environment_id: z11.string().describe(`Environment id from \`${REPLICAS_MCP_TOOLS.listEnvironments}\`.`),
-  triggers: z11.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: z11.string().optional().describe("One-line summary shown in the dashboard.")
+// ../shared/src/routes/environment.ts
+import { z as z11 } from "zod";
+var ENVIRONMENT_MCP_TRANSPORTS = ["stdio", "http", "sse"];
+var stringMap = z11.record(z11.string(), z11.string());
+var createEnvironmentMcpRequestSchema = z11.object({
+  name: z11.string(),
+  transport: z11.enum(ENVIRONMENT_MCP_TRANSPORTS),
+  config: z11.union([
+    z11.object({ command: z11.string().min(1), args: z11.array(z11.string()).optional(), env: stringMap.optional() }),
+    z11.object({ url: z11.url(), headers: stringMap.optional(), auth: mcpWorkloadAuthSchema.optional() })
+  ]).describe("stdio: `{ command, args, env }`. http/sse: `{ url, headers }`.")
 });
+var updateEnvironmentMcpRequestSchema = createEnvironmentMcpRequestSchema.partial();
+
+// ../shared/src/routes/workspaces.ts
+import { z as z13 } from "zod";
 
 // ../shared/src/default-skills/replicas-agent/abilities/computer.ts
 var SECTION = `### Computer use (Linux desktop control)
@@ -4883,6 +4929,100 @@ var REPLICAS_AGENT_ABILITIES = Object.keys(
   REPLICAS_AGENT_ABILITY_REGISTRY
 );
 
+// ../shared/src/routes/workspaces.ts
+var WORKSPACE_STATUSES = ["active", "sleeping", "archived", "preparing", "error"];
+var STALE_PREPARING_MS = 10 * 6e4;
+var VALID_LIFECYCLE_POLICIES = ["default", "archive_when_done", "sleep_when_done", "delete_after_inactivity"];
+var WORKSPACE_STATUS_FILTERS = WORKSPACE_STATUSES.map((status) => status === "error" ? "failed" : status);
+var WORKSPACE_SORT_CHOICES = [
+  ["manual", "Custom"],
+  ["activity", "Last activity"],
+  ["created", "Created date"]
+];
+var WORKSPACE_SORT_OPTIONS = WORKSPACE_SORT_CHOICES.map(([option]) => option);
+var WORKSPACE_SORT_LABELS = Object.fromEntries(WORKSPACE_SORT_CHOICES);
+var WORKSPACE_SIDEBAR_ORGANIZATION_CHOICES = [
+  ["chronological", "Chronological"],
+  ["environments", "Environments"],
+  ["recent", "Recent environments"]
+];
+var WORKSPACE_SIDEBAR_ORGANIZATIONS = WORKSPACE_SIDEBAR_ORGANIZATION_CHOICES.map(([organization]) => organization);
+var WORKSPACE_SIDEBAR_ORGANIZATION_LABELS = Object.fromEntries(WORKSPACE_SIDEBAR_ORGANIZATION_CHOICES);
+var DEFAULT_STATUS_FILTERS = [...WORKSPACE_STATUS_FILTERS];
+var DEFAULT_WORKSPACE_FILTERS = {
+  statuses: [...DEFAULT_STATUS_FILTERS],
+  ownerIds: [],
+  activity: "any"
+};
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var workspaceExecRequestSchema = z13.object({
+  command: z13.string().regex(/\S/, "command is required"),
+  timeout_seconds: z13.number().int().min(1).max(50).optional().describe("Default: 30")
+});
+var terminalRtcCandidateSchema = z13.object({ type: z13.literal("rtc-candidate"), candidate: z13.string(), mid: z13.string() });
+var terminalSocketServerMessageSchema = z13.discriminatedUnion("type", [
+  z13.object({ type: z13.literal("output"), data: z13.string() }),
+  z13.object({ type: z13.literal("rtc-answer"), sdp: z13.string() }),
+  terminalRtcCandidateSchema,
+  z13.object({ type: z13.literal("rtc-switch") })
+]);
+var TERMINAL_RTC_ICE_SERVER = "stun:stun.l.google.com:19302";
+
+// ../shared/src/replicas-mcp.ts
+var REPLICAS_MCP_TOOLS = {
+  listEnvironments: "list_environments",
+  createAutomation: "create_automation",
+  spawn: "spawn_workspace",
+  relay: "relay_to_workspace",
+  linearStart: "start_linear_session",
+  linearSessionIntent: "register_linear_session_intent",
+  listChannelSettings: "list_channel_settings",
+  saveChannelPreset: "save_channel_preset",
+  updateChannelSettings: "update_channel_settings",
+  spawnSubagent: "spawn_subagent",
+  messageSubagent: "message_subagent",
+  listSubagents: "list_subagents",
+  readSubagent: "read_subagent",
+  archiveSubagent: "archive_subagent"
+};
+var automationToolInputSchema = z14.object({
+  name: z14.string().describe("Short automation name."),
+  prompt: z14.string().describe("Prompt each automation run starts with."),
+  environment_id: z14.string().describe(`Environment id from \`${REPLICAS_MCP_TOOLS.listEnvironments}\`.`),
+  triggers: z14.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: z14.string().optional().describe("One-line summary shown in the dashboard."),
+  plan_mode: z14.boolean().optional(),
+  goal_mode: z14.boolean().optional(),
+  fast_mode: z14.boolean().optional()
+});
+var automationCreateToolInputSchema = automationToolInputSchema.extend({
+  scope: z14.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: z14.string().describe("Automation ID"),
+  enabled: z14.boolean().optional(),
+  agent_provider: z14.enum(AGENT).nullable().optional(),
+  model: z14.string().nullable().optional(),
+  thinking_level: z14.enum(VALID_THINKING_LEVELS).nullable().optional(),
+  workspace_lifecycle_policy: z14.enum(VALID_LIFECYCLE_POLICIES).optional(),
+  workspace_size: z14.enum(WORKSPACE_SIZES).optional()
+});
+var chatPath = { id: z14.string().describe("Workspace ID"), chat_id: z14.string().describe("Chat ID") };
+var { provider, model, thinkingLevel, title, message } = forkChatRequestSchema.shape;
+var createChatToolInputSchema = z14.object({ id: chatPath.id, provider, title: createChatRequestSchema.shape.title });
+var forkChatToolInputSchema = z14.object({ ...chatPath, provider, model, thinkingLevel, title, message });
+var renameChatToolInputSchema = z14.object({ ...chatPath, ...updateChatDisplayNameRequestSchema.shape });
+var runCommandToolInputSchema = z14.object({ id: chatPath.id, ...workspaceExecRequestSchema.shape });
+var environmentMcpPath = { environment_id: z14.string().describe("Environment ID") };
+var createEnvironmentMcpToolInputSchema = z14.object({ ...environmentMcpPath, ...createEnvironmentMcpRequestSchema.shape });
+var updateEnvironmentMcpToolInputSchema = z14.object({
+  ...environmentMcpPath,
+  mcp_id: z14.string().describe("MCP ID"),
+  ...updateEnvironmentMcpRequestSchema.shape
+});
+
 // ../shared/src/routes/preferences.ts
 var EMPTY_AGENT_DEFAULT_SETTINGS = {
   agent_provider: null,
@@ -5029,8 +5169,8 @@ function messagesForCodexTurn(turn) {
     coalesced.splice(responseIndex, 0, ...coalesced.splice(reasoningIndex, 1));
   }
   const messages = coalesced.flatMap((item) => {
-    const message = messageForItem(item);
-    return [...message ? [message] : [], ...skillMessagesForItem(item)];
+    const message2 = messageForItem(item);
+    return [...message2 ? [message2] : [], ...skillMessagesForItem(item)];
   });
   if (turn.error) {
     messages.push({
@@ -5307,11 +5447,11 @@ function parseCodexEvents(events) {
       return;
     }
     if (event.type === "event_msg" && event.payload?.type === "user_message") {
-      const message = getPayloadString(event, "message");
+      const message2 = getPayloadString(event, "message");
       messages.push({
         id: displayId(event, eventIndex, "user"),
         type: "user",
-        content: message ?? "",
+        content: message2 ?? "",
         images: userMessageImages(event.payload.images),
         timestamp: event.timestamp
       });
@@ -5447,34 +5587,34 @@ function parseCodexEvents(events) {
     }
   });
   const recordedPrompts = /* @__PURE__ */ new Map();
-  messages.forEach((message, index) => {
-    if (message.type !== "user") return;
-    const prompts = recordedPrompts.get(message.content) ?? [];
-    prompts.push({ message, index, timestampMs: parseTimestampMs(message.timestamp) });
-    recordedPrompts.set(message.content, prompts);
+  messages.forEach((message2, index) => {
+    if (message2.type !== "user") return;
+    const prompts = recordedPrompts.get(message2.content) ?? [];
+    prompts.push({ message: message2, index, timestampMs: parseTimestampMs(message2.timestamp) });
+    recordedPrompts.set(message2.content, prompts);
   });
   const claimedPrompts = /* @__PURE__ */ new Set();
   for (const { index, turnId } of turnInsertions.reverse()) {
     const turn = turns.get(turnId);
     if (!turn) continue;
     const kept = [];
-    for (const message of messagesForCodexTurn(turn)) {
-      if (message.type !== "user") {
-        kept.push(message);
+    for (const message2 of messagesForCodexTurn(turn)) {
+      if (message2.type !== "user") {
+        kept.push(message2);
         continue;
       }
-      const prompts = recordedPrompts.get(message.content);
-      const recorded = prompts && takeRecordedPrompt(prompts, message, index);
+      const prompts = recordedPrompts.get(message2.content);
+      const recorded = prompts && takeRecordedPrompt(prompts, message2, index);
       if (!recorded) {
-        kept.push(message);
+        kept.push(message2);
         continue;
       }
       claimedPrompts.add(recorded);
-      kept.push({ ...recorded, images: recorded.images ?? message.images });
+      kept.push({ ...recorded, images: recorded.images ?? message2.images });
     }
     messages.splice(index, 0, ...kept);
   }
-  return messages.filter((message) => !claimedPrompts.has(message));
+  return messages.filter((message2) => !claimedPrompts.has(message2));
 }
 
 // ../shared/src/display-message/parsers/cursor-parser.ts
@@ -5490,24 +5630,24 @@ function cursorRunId(event) {
   return typeof runId === "string" ? runId : "unknown-run";
 }
 function getCursorAssistantText(event) {
-  const message = isRecord(event.payload.message) ? event.payload.message : null;
-  return getTextContent(message?.content);
+  const message2 = isRecord(event.payload.message) ? event.payload.message : null;
+  return getTextContent(message2?.content);
 }
 function getCursorThinkingText(event) {
   const text2 = event.payload.text;
   if (typeof text2 === "string") return text2;
-  const message = isRecord(event.payload.message) ? event.payload.message : null;
-  return typeof message?.text === "string" ? message.text : "";
+  const message2 = isRecord(event.payload.message) ? event.payload.message : null;
+  return typeof message2?.text === "string" ? message2.text : "";
 }
 function isTerminalStatus(status) {
   return status === "FINISHED" || status === "ERROR" || status === "CANCELLED" || status === "EXPIRED";
 }
 function finalizeOpenCalls(messages, callIndexes, status) {
   for (const index of callIndexes.values()) {
-    const message = messages[index];
-    if ((message?.type === "tool_call" || message?.type === "skill") && message.status === "in_progress") {
+    const message2 = messages[index];
+    if ((message2?.type === "tool_call" || message2?.type === "skill") && message2.status === "in_progress") {
       messages[index] = {
-        ...message,
+        ...message2,
         status
       };
     }
@@ -5522,10 +5662,10 @@ function parseCursorEvents(events) {
   let activeThinking = null;
   const finalizeActiveThinking = (status) => {
     if (!activeThinking) return;
-    const message = messages[activeThinking.index];
-    if (message?.type === "reasoning") {
+    const message2 = messages[activeThinking.index];
+    if (message2?.type === "reasoning") {
       messages[activeThinking.index] = {
-        ...message,
+        ...message2,
         status
       };
     }
@@ -5534,12 +5674,12 @@ function parseCursorEvents(events) {
     if (event.type === "event_msg" && event.payload.type === "user_message") {
       activeAssistant = null;
       activeThinking = null;
-      const message = event.payload.message;
-      if (typeof message === "string" && message.trim()) {
+      const message2 = event.payload.message;
+      if (typeof message2 === "string" && message2.trim()) {
         messages.push({
           id: getUserMessageId(event) ?? `cursor-user-${event.timestamp}-${messages.length}`,
           type: "user",
-          content: message,
+          content: message2,
           timestamp: event.timestamp
         });
       }
@@ -5562,11 +5702,11 @@ function parseCursorEvents(events) {
             }) - 1
           };
         }
-        const message = messages[activeAssistant.index];
-        if (message?.type === "agent") {
+        const message2 = messages[activeAssistant.index];
+        if (message2?.type === "agent") {
           messages[activeAssistant.index] = {
-            ...message,
-            content: `${message.content}${text2}`
+            ...message2,
+            content: `${message2.content}${text2}`
           };
         }
       }
@@ -5590,11 +5730,11 @@ function parseCursorEvents(events) {
             }) - 1
           };
         }
-        const message = messages[activeThinking.index];
-        if (message?.type === "reasoning") {
+        const message2 = messages[activeThinking.index];
+        if (message2?.type === "reasoning") {
           messages[activeThinking.index] = {
-            ...message,
-            content: `${message.content}${text2}`,
+            ...message2,
+            content: `${message2.content}${text2}`,
             status: "in_progress"
           };
         }
@@ -5653,11 +5793,11 @@ function parseCursorEvents(events) {
       finalizeOpenCalls(messages, callIndexes, "failed");
       activeAssistant = null;
       activeThinking = null;
-      const message = typeof event.payload.message === "string" ? event.payload.message : "Cursor run failed";
+      const message2 = typeof event.payload.message === "string" ? event.payload.message : "Cursor run failed";
       messages.push({
         id: `cursor-error-${event.timestamp}-${messages.length}`,
         type: "error",
-        message,
+        message: message2,
         timestamp: event.timestamp
       });
     }
@@ -5739,16 +5879,16 @@ var TRANSIENT_HTTP_STATUSES = [408, 429, 500, 502, 503, 504, 529];
 var SERVER_ERROR_TEXT_PATTERN = /internal ?server ?error|server ?error|service unavailable|bad gateway|gateway timeout|overloaded|too many requests/i;
 var INFERENCE_ERROR_DETAIL_MAX = 600;
 var INFERENCE_ERROR_RETRY_HINT = "This is usually temporary \u2014 retry the message.";
-function formatInferenceError(message, context = {}) {
+function formatInferenceError(message2, context = {}) {
   const label = context.provider ? INFERENCE_PROVIDER_LABELS[context.provider] ?? context.provider : null;
   const source = label ? `${label}${context.model ? ` (${context.model})` : ""} request failed${typeof context.status === "number" ? ` with HTTP ${context.status}` : ""}` : null;
-  let body = source ? message ? `${source}: ${message}` : `${source}.` : message;
+  let body = source ? message2 ? `${source}: ${message2}` : `${source}.` : message2;
   const detail = context.detail?.trim();
   if (detail && !body.includes(detail)) {
     body = `${body}
 ${detail.length > INFERENCE_ERROR_DETAIL_MAX ? `${detail.slice(0, INFERENCE_ERROR_DETAIL_MAX)}\u2026` : detail}`;
   }
-  const sniffText = `${message}
+  const sniffText = `${message2}
 ${detail ?? ""}`;
   const transient = context.retryable ?? (typeof context.status === "number" ? TRANSIENT_HTTP_STATUSES.includes(context.status) || context.status >= 500 : isTransientErrorText(sniffText, { httpStatuses: TRANSIENT_HTTP_STATUSES, includeRateLimit: true }) || SERVER_ERROR_TEXT_PATTERN.test(sniffText));
   return transient ? `${body}
@@ -5768,9 +5908,9 @@ function toolStatus(status) {
 function assistantError(info) {
   if (!isRecord(info) || !isRecord(info.error)) return null;
   const data = isRecord(info.error.data) ? info.error.data : null;
-  const message = typeof data?.message === "string" ? data.message : typeof info.error.message === "string" ? info.error.message : stringifyDisplayValue(info.error) ?? "Opencode run failed";
-  if (info.error.name === "MessageAbortedError") return message;
-  return formatInferenceError(message, {
+  const message2 = typeof data?.message === "string" ? data.message : typeof info.error.message === "string" ? info.error.message : stringifyDisplayValue(info.error) ?? "Opencode run failed";
+  if (info.error.name === "MessageAbortedError") return message2;
+  return formatInferenceError(message2, {
     ...typeof info.providerID === "string" ? { provider: info.providerID } : {},
     ...typeof info.modelID === "string" ? { model: info.modelID } : {},
     ...typeof data?.statusCode === "number" ? { status: data.statusCode } : {},
@@ -5782,13 +5922,13 @@ function parseOpencodeEvents(events) {
   const messages = [];
   for (const event of events) {
     if (event.type === "event_msg" && event.payload.type === "user_message") {
-      const message = event.payload.message;
-      if (typeof message === "string" && message.trim()) {
+      const message2 = event.payload.message;
+      if (typeof message2 === "string" && message2.trim()) {
         const messageId = event.payload[USER_MESSAGE_ID_PAYLOAD_KEY];
         messages.push({
           id: typeof messageId === "string" ? messageId : `opencode-user-${event.timestamp}`,
           type: "user",
-          content: message,
+          content: message2,
           timestamp: event.timestamp
         });
       }
@@ -5807,11 +5947,11 @@ function parseOpencodeEvents(events) {
       continue;
     }
     if (event.type === "opencode-error") {
-      const message = typeof event.payload.message === "string" ? event.payload.message : "Opencode run failed";
+      const message2 = typeof event.payload.message === "string" ? event.payload.message : "Opencode run failed";
       messages.push({
         id: `opencode-${event.type}-${event.timestamp}`,
         type: "error",
-        message: formatInferenceError(message, {
+        message: formatInferenceError(message2, {
           ...typeof event.payload.status === "number" ? { status: event.payload.status } : {}
         }),
         timestamp: event.timestamp
@@ -5993,7 +6133,7 @@ function parseMuseEvents(events) {
         } catch {
         }
       }
-      const message = createCallDisplayMessage({
+      const message2 = createCallDisplayMessage({
         id: `muse-tool-${item.itemId}`,
         server: "muse",
         tool: typeof item.tool === "string" ? item.tool : "tool",
@@ -6003,7 +6143,7 @@ function parseMuseEvents(events) {
         status: item.status === "failed" || item.status === "rejected" ? "failed" : terminal ? "completed" : "in_progress",
         timestamp: typeof item.recordedAt === "string" ? item.recordedAt : event.timestamp
       });
-      upsertDisplayMessage(messages, message);
+      upsertDisplayMessage(messages, message2);
     }
   }
   return messages;
@@ -6018,8 +6158,8 @@ function toolStatus2(value) {
 }
 function assistantErrorMessage(value) {
   if (!isRecord(value) || value.role !== "assistant" || value.stopReason !== "error") return null;
-  const message = typeof value.errorMessage === "string" && value.errorMessage ? value.errorMessage : "Pi run failed";
-  return formatInferenceError(message, {
+  const message2 = typeof value.errorMessage === "string" && value.errorMessage ? value.errorMessage : "Pi run failed";
+  return formatInferenceError(message2, {
     ...typeof value.provider === "string" ? { provider: value.provider } : {},
     ...typeof value.model === "string" ? { model: value.model } : {}
   });
@@ -6066,8 +6206,8 @@ function parsePiEvents(events) {
       continue;
     }
     if (event.type === "pi-message_start") {
-      const message = isRecord(event.payload.message) ? event.payload.message : null;
-      activeMessageId = typeof message?.id === "string" ? message.id : `assistant-${event.timestamp}`;
+      const message2 = isRecord(event.payload.message) ? event.payload.message : null;
+      activeMessageId = typeof message2?.id === "string" ? message2.id : `assistant-${event.timestamp}`;
       continue;
     }
     if (event.type === "pi-tool_execution_start" || event.type === "pi-tool_execution_update" || event.type === "pi-tool_execution_end") {
@@ -6266,8 +6406,8 @@ function fileOrCommandMessage(toolName, toolUseId, input, timestamp) {
   };
 }
 function createSubagentMessage(messageIndex, timestamp, fields) {
-  const { id = `subagent-${timestamp}-${messageIndex}`, ...message } = fields;
-  return { id, type: "subagent", ...message, timestamp };
+  const { id = `subagent-${timestamp}-${messageIndex}`, ...message2 } = fields;
+  return { id, type: "subagent", ...message2, timestamp };
 }
 function collectNestedEvents(events, toolUseId) {
   return events.filter((e) => e.payload.parent_tool_use_id === toolUseId).map(({ timestamp, type, payload }) => ({ timestamp, type, payload }));
@@ -6324,12 +6464,12 @@ function parseClaudeEvents(events, parentToolUseId) {
   const supersededUserMessageIndexes = /* @__PURE__ */ new Set();
   const findMatchingUserMessageIndex = (indexes, content, timestamp, messageId) => {
     if (typeof messageId === "string") {
-      const byId = messages.findIndex((message, index) => message.type === "user" && message.id === messageId && !supersededUserMessageIndexes.has(index));
+      const byId = messages.findIndex((message2, index) => message2.type === "user" && message2.id === messageId && !supersededUserMessageIndexes.has(index));
       if (byId !== -1) return byId;
     }
     return [...indexes].find((index) => {
-      const message = messages[index];
-      return message?.type === "user" && areUserMessagesWithinMatchWindow(message, { content, timestamp });
+      const message2 = messages[index];
+      return message2?.type === "user" && areUserMessagesWithinMatchWindow(message2, { content, timestamp });
     });
   };
   const taskAccumulator = new TaskAccumulator();
@@ -6346,7 +6486,7 @@ function parseClaudeEvents(events, parentToolUseId) {
         const messageId = event.payload[USER_MESSAGE_ID_PAYLOAD_KEY];
         const canonicalIndex = findMatchingUserMessageIndex(canonicalUserMessageIndexes, content, event.timestamp, messageId);
         const canonical = canonicalIndex === void 0 ? void 0 : messages[canonicalIndex];
-        const message = {
+        const message2 = {
           id: typeof messageId === "string" ? messageId : `user-${event.timestamp}`,
           type: "user",
           content,
@@ -6354,9 +6494,9 @@ function parseClaudeEvents(events, parentToolUseId) {
           timestamp: event.timestamp
         };
         if (canonicalIndex === void 0) {
-          acceptedUserMessageIndexes.add(messages.push(message) - 1);
+          acceptedUserMessageIndexes.add(messages.push(message2) - 1);
         } else {
-          messages[canonicalIndex] = message;
+          messages[canonicalIndex] = message2;
           canonicalUserMessageIndexes.delete(canonicalIndex);
         }
       }
@@ -6428,7 +6568,7 @@ function parseClaudeEvents(events, parentToolUseId) {
           stampedId
         );
         const accepted = acceptedIndex === void 0 ? void 0 : messages[acceptedIndex];
-        const message = {
+        const message2 = {
           id: accepted?.id ?? (typeof stampedId === "string" ? stampedId : `user-${event.timestamp}`),
           type: "user",
           content: textContent || (images.length > 0 ? `[${images.length} image${images.length > 1 ? "s" : ""} attached]` : ""),
@@ -6436,13 +6576,13 @@ function parseClaudeEvents(events, parentToolUseId) {
           timestamp: event.timestamp
         };
         if (acceptedIndex === void 0) {
-          canonicalUserMessageIndexes.add(messages.push(message) - 1);
+          canonicalUserMessageIndexes.add(messages.push(message2) - 1);
         } else if (acceptedUserMessageIndexes.has(acceptedIndex)) {
           supersededUserMessageIndexes.add(acceptedIndex);
           acceptedUserMessageIndexes.delete(acceptedIndex);
-          canonicalUserMessageIndexes.add(messages.push(message) - 1);
+          canonicalUserMessageIndexes.add(messages.push(message2) - 1);
         } else {
-          messages[acceptedIndex] = message;
+          messages[acceptedIndex] = message2;
         }
       }
     }
@@ -6568,15 +6708,14 @@ function parseClaudeEvents(events, parentToolUseId) {
               timestamp: event.timestamp
             });
           } else {
-            messages.push({
+            messages.push(createCallDisplayMessage({
               id: `toolcall-${event.timestamp}-${messages.length}`,
-              type: "tool_call",
               server: "claude",
               tool: toolName,
               input: toolInput,
               status: "in_progress",
               timestamp: event.timestamp
-            });
+            }));
           }
         }
       });
@@ -6666,9 +6805,9 @@ function parseClaudeEvents(events, parentToolUseId) {
       if (!Array.isArray(payload.options) && !Array.isArray(payload.questions)) return;
       const toolInfo = toolCallMap.get(payload.toolUseId);
       if (!toolInfo) return;
-      const message = messages[toolInfo.messageIndex];
-      if (!message || message.type !== "tool_call") return;
-      message.inputRequest = {
+      const message2 = messages[toolInfo.messageIndex];
+      if (!message2 || message2.type !== "tool_call") return;
+      message2.inputRequest = {
         requestId: payload.requestId,
         status: "pending",
         options: payload.options,
@@ -6680,10 +6819,10 @@ function parseClaudeEvents(events, parentToolUseId) {
       if (!payload.toolUseId || !payload.selectionId) return;
       const toolInfo = toolCallMap.get(payload.toolUseId);
       if (!toolInfo) return;
-      const message = messages[toolInfo.messageIndex];
-      if (!message || message.type !== "tool_call" || !message.inputRequest) return;
-      message.inputRequest = {
-        ...message.inputRequest,
+      const message2 = messages[toolInfo.messageIndex];
+      if (!message2 || message2.type !== "tool_call" || !message2.inputRequest) return;
+      message2.inputRequest = {
+        ...message2.inputRequest,
         status: payload.selectionId === "aborted" ? "aborted" : "resolved",
         selectionId: payload.selectionId,
         selectionSummary: payload.selectionSummary
@@ -6705,39 +6844,41 @@ function parseClaudeEvents(events, parentToolUseId) {
     if (toolInfo.toolName === "TaskCreate" && !isError) {
       taskAccumulator.processContentBlock(toolResult);
     }
-    const message = messages[toolInfo.messageIndex];
-    if (!message) return;
-    if (message.type === "command") {
-      message.output = resultContent;
-      message.status = status;
+    const message2 = messages[toolInfo.messageIndex];
+    if (!message2) return;
+    if (message2.type === "command") {
+      message2.output = resultContent;
+      message2.status = status;
       const exitCodeMatch = resultContent.match(/exit code:?\s*(\d+)/i);
       if (exitCodeMatch) {
-        message.exitCode = parseInt(exitCodeMatch[1], 10);
+        message2.exitCode = parseInt(exitCodeMatch[1], 10);
       } else {
-        message.exitCode = isError ? 1 : 0;
+        message2.exitCode = isError ? 1 : 0;
       }
-    } else if (message.type === "patch") {
-      message.status = status;
-    } else if (message.type === "web_search") {
-      message.status = status;
-    } else if (message.type === "tool_call") {
-      message.output = resultContent;
-      message.status = status;
-    } else if (message.type === "skill") {
-      message.status = status;
-    } else if (message.type === "subagent") {
-      message.output = resultContent;
-      message.status = status;
+    } else if (message2.type === "patch") {
+      message2.status = status;
+    } else if (message2.type === "web_search") {
+      message2.status = status;
+    } else if (message2.type === "tool_call") {
+      message2.output = resultContent;
+      message2.status = status;
+    } else if (message2.type === "skill" && isError && message2.path) {
+      messages[toolInfo.messageIndex] = { id: message2.id, type: "tool_call", server: "claude", tool: toolInfo.toolName, input: toolInfo.input, output: resultContent, status, timestamp: message2.timestamp };
+    } else if (message2.type === "skill") {
+      message2.status = status;
+    } else if (message2.type === "subagent") {
+      message2.output = resultContent;
+      message2.status = status;
     }
   });
-  for (const message of messages) {
-    if (message.type === "background_task" && message.toolUseId) {
-      const toolInfo = toolCallMap.get(message.toolUseId);
+  for (const message2 of messages) {
+    if (message2.type === "background_task" && message2.toolUseId) {
+      const toolInfo = toolCallMap.get(message2.toolUseId);
       const toolMessage = toolInfo ? messages[toolInfo.messageIndex] : void 0;
-      if (toolMessage?.type === "command") message.command = toolMessage.command;
+      if (toolMessage?.type === "command") message2.command = toolMessage.command;
       if (toolMessage?.type === "subagent") {
-        message.prompt ??= toolMessage.prompt;
-        message.subagentType ??= toolMessage.subagentType;
+        message2.prompt ??= toolMessage.prompt;
+        message2.subagentType ??= toolMessage.subagentType;
       }
     }
   }
@@ -6789,9 +6930,9 @@ function parseDisplayMessages(events, agentType, options = {}) {
   events = excludeQueuedAcceptedEvents(events, []);
   const parsedEvents = agentType === "claude" ? parseClaudeEvents(events, options.parentToolUseId) : parseAgentEvents(events, agentType);
   const reconciledEvents = [];
-  for (const message of parsedEvents) {
-    if (message.type === "user") upsertDisplayMessage(reconciledEvents, message);
-    else reconciledEvents.push(message);
+  for (const message2 of parsedEvents) {
+    if (message2.type === "user") upsertDisplayMessage(reconciledEvents, message2);
+    else reconciledEvents.push(message2);
   }
   if (options.filter === false) return reconciledEvents;
   return applyAuthFallbackNotices(
@@ -6853,17 +6994,17 @@ function applyAuthFallbackNotices(messages, events) {
   for (const notice of notices) insertDisplayMessageByTimestamp(result, notice);
   return result;
 }
-function isCodexInitializationPrompt(message) {
-  return message.type === "user" && removeReplicasInstructions(message.content).trim() === "Hello";
+function isCodexInitializationPrompt(message2) {
+  return message2.type === "user" && removeReplicasInstructions(message2.content).trim() === "Hello";
 }
 function isAgentBackendEvent(value) {
   if (!value || typeof value !== "object") return false;
   const candidate = value;
   return typeof candidate.timestamp === "string" && typeof candidate.type === "string" && typeof candidate.payload === "object" && candidate.payload !== null;
 }
-function filterDisplayMessages(messages, provider) {
+function filterDisplayMessages(messages, provider2) {
   let result = messages;
-  if (provider === "codex") {
+  if (provider2 === "codex") {
     const userMessages = result.map((msg, index) => ({ msg, index })).filter(({ msg }) => msg.type === "user");
     if (userMessages.length >= 2 && isCodexInitializationPrompt(userMessages[0].msg)) {
       result = result.slice(userMessages[1].index);
@@ -6894,24 +7035,24 @@ function attachSendersToMessages(messages, senders) {
   const sendersByMessageId = new Map(senders.flatMap((sender) => sender.messageId ? [[sender.messageId, sender], [`user-${sender.messageId}`, sender]] : []));
   const legacySenders = senders.filter((sender) => !sender.messageId);
   const userIndices = [];
-  const attachSender = (message, sender) => message.type === "user" ? {
-    ...message,
+  const attachSender = (message2, sender) => message2.type === "user" ? {
+    ...message2,
     senderUserId: sender.senderUserId,
     senderEmail: sender.senderEmail,
     ...sender.senderDisplayName ? { senderDisplayName: sender.senderDisplayName } : {},
     ...sender.senderAvatarUrl ? { senderAvatarUrl: sender.senderAvatarUrl } : {}
-  } : message;
-  const next = messages.map((message) => {
-    const sender = message.type === "user" ? sendersByMessageId.get(message.id) : void 0;
-    return sender ? attachSender(message, sender) : message;
+  } : message2;
+  const next = messages.map((message2) => {
+    const sender = message2.type === "user" ? sendersByMessageId.get(message2.id) : void 0;
+    return sender ? attachSender(message2, sender) : message2;
   });
-  messages.forEach((message, index) => {
-    if (message.type === "user" && !sendersByMessageId.has(message.id)) {
+  messages.forEach((message2, index) => {
+    if (message2.type === "user" && !sendersByMessageId.has(message2.id)) {
       userIndices.push(index);
     }
   });
   const timestampSenders = senders.filter((sender) => sender.messageId && !messages.some(
-    (message) => message.type === "user" && sendersByMessageId.get(message.id) === sender
+    (message2) => message2.type === "user" && sendersByMessageId.get(message2.id) === sender
   ));
   for (const sender of timestampSenders) {
     const senderTime = parseTimestampMs(sender.recordedAt);
@@ -6935,9 +7076,9 @@ function attachSendersToMessages(messages, senders) {
 }
 
 // ../shared/src/display-message/final-response.ts
-function extractFinalResponse(history, provider) {
-  const message = parseAgentEvents(history.events ?? [], provider).findLast((candidate) => candidate.type === "agent");
-  return message?.type === "agent" && message.content ? message.content : null;
+function extractFinalResponse(history, provider2) {
+  const message2 = parseAgentEvents(history.events ?? [], provider2).findLast((candidate) => candidate.type === "agent");
+  return message2?.type === "agent" && message2.content ? message2.content : null;
 }
 
 // ../shared/src/agent-event-utils.ts
@@ -6960,7 +7101,7 @@ function getUserMessageItemId(event) {
   return typeof itemId === "string" ? itemId : null;
 }
 function excludeQueuedAcceptedEvents(events, queue, removedMessageIds = []) {
-  const queuedMessageIds = /* @__PURE__ */ new Set([...queue.map((message) => message.id), ...removedMessageIds]);
+  const queuedMessageIds = /* @__PURE__ */ new Set([...queue.map((message2) => message2.id), ...removedMessageIds]);
   for (const event of events) {
     for (const messageId of getRemovedMessageIds(event)) queuedMessageIds.add(messageId);
   }
@@ -7058,25 +7199,25 @@ function redactSecrets(value) {
 }
 
 // ../shared/src/transcript-canonicalize.ts
-function canonicalizeChatTranscriptBlocks(content, provider, senders) {
+function canonicalizeChatTranscriptBlocks(content, provider2, senders) {
   const messages = attachSendersToMessages(
-    parseDisplayMessages(parseCodexHistoryEvents(content), provider),
+    parseDisplayMessages(parseCodexHistoryEvents(content), provider2),
     senders
   );
-  return messages.flatMap((message) => {
+  return messages.flatMap((message2) => {
     let block = null;
-    if (message.type === "user") {
-      block = `## User${message.senderEmail ? ` (${message.senderEmail})` : ""}
-${message.content}`;
-    } else if (message.type === "agent") {
+    if (message2.type === "user") {
+      block = `## User${message2.senderEmail ? ` (${message2.senderEmail})` : ""}
+${message2.content}`;
+    } else if (message2.type === "agent") {
       block = `## Agent
-${message.content}`;
-    } else if (message.type === "reasoning") {
+${message2.content}`;
+    } else if (message2.type === "reasoning") {
       block = `## Agent reasoning (unverified)
-Timestamp: ${message.sourceTimestamp ?? message.timestamp}
-${message.content}`;
+Timestamp: ${message2.sourceTimestamp ?? message2.timestamp}
+${message2.content}`;
     } else {
-      const activity = getDisplayMessageActivity(message);
+      const activity = getDisplayMessageActivity(message2);
       if (activity) {
         const details = [];
         if (activity.summary) details.push(`Summary: ${activity.summary}`);
@@ -7086,7 +7227,7 @@ ${activity.items.map((item) => `- [${item.status}] ${item.text}`).join("\n")}`);
         }
         if (activity.content) details.push(`Details:
 ${activity.content}`);
-        if (message.type === "command" && message.exitCode != null) details.push(`Exit: ${message.exitCode}`);
+        if (message2.type === "command" && message2.exitCode != null) details.push(`Exit: ${message2.exitCode}`);
         block = `## Activity
 ${activity.title}${details.length > 0 ? `
 ${details.join("\n")}` : ""}`;
@@ -7144,7 +7285,7 @@ ${CLOSE_MARKER}
 
 ${instruction}`;
 }
-function formatSideChatUpdateMessage(source, turns, message) {
+function formatSideChatUpdateMessage(source, turns, message2) {
   const meta = { sourceProvider: source.provider, sourceTitle: source.title, trigger: "side" };
   return `${OPEN_MARKER}${JSON.stringify(meta)}${OPEN_MARKER_END}
 # Main chat update
@@ -7154,7 +7295,7 @@ The main chat "${source.title}" has new turns since your last reply:
 ${turns}
 ${CLOSE_MARKER}
 
-${message}`;
+${message2}`;
 }
 
 // ../shared/src/transcript-condense.ts
@@ -7333,27 +7474,27 @@ function buildCodexTokenUsageContextUsagePayload(usage) {
     updatedAt: usage.updatedAt
   };
 }
-function resolveClaudeContextWindow(provider, model, reportedMaxTokens) {
-  if (provider !== "claude") {
+function resolveClaudeContextWindow(provider2, model2, reportedMaxTokens) {
+  if (provider2 !== "claude") {
     return { maxTokens: reportedMaxTokens, usedKnownWindow: false };
   }
-  const knownWindow = getClaudeModelContextWindow(model);
+  const knownWindow = getClaudeModelContextWindow(model2);
   return {
     maxTokens: knownWindow ?? reportedMaxTokens,
     usedKnownWindow: knownWindow !== null
   };
 }
 function coerceContextUsagePayload(payload, timestamp) {
-  const provider = payload.provider;
-  if (typeof provider !== "string" || !isValidAgentProvider(provider)) return null;
+  const provider2 = payload.provider;
+  if (typeof provider2 !== "string" || !isValidAgentProvider(provider2)) return null;
   const rawTotalTokens = numberOrNull(payload.totalTokens);
   const percentageValue = numberOrNull(payload.percentage);
   if (rawTotalTokens === null || percentageValue === null) {
     return null;
   }
-  const model = typeof payload.model === "string" ? payload.model : null;
+  const model2 = typeof payload.model === "string" ? payload.model : null;
   const reportedMaxTokens = numberOrNull(payload.maxTokens);
-  const { maxTokens, usedKnownWindow } = resolveClaudeContextWindow(provider, model, reportedMaxTokens);
+  const { maxTokens, usedKnownWindow } = resolveClaudeContextWindow(provider2, model2, reportedMaxTokens);
   const rawMaxTokens = usedKnownWindow ? maxTokens : numberOrNull(payload.rawMaxTokens);
   const totalTokens = clampTokensToWindow(rawTotalTokens, maxTokens);
   const source = payload.source === "codex_token_count" || payload.source === "claude_usage" || payload.source === "provider_usage" ? payload.source : "claude_context";
@@ -7373,9 +7514,9 @@ function coerceContextUsagePayload(payload, timestamp) {
   const compactsAutomatically = typeof payload.compactsAutomatically === "boolean" ? payload.compactsAutomatically : void 0;
   const autoCompactThreshold = normalizeAutoCompactThreshold(payload.autoCompactThreshold, maxTokens);
   return {
-    provider,
+    provider: provider2,
     source,
-    ...model ? { model } : {},
+    ...model2 ? { model: model2 } : {},
     totalTokens,
     maxTokens,
     rawMaxTokens,
@@ -7406,18 +7547,18 @@ function codexTokenCountToContextUsage(event) {
     updatedAt: event.timestamp
   });
 }
-function extractLatestContextUsage(events, provider) {
+function extractLatestContextUsage(events, provider2) {
   if (!events || events.length === 0) return null;
   let latest = null;
   for (const event of events) {
     if (event.type === CONTEXT_USAGE_EVENT_TYPE) {
       const usage = coerceContextUsagePayload(event.payload, event.timestamp);
-      if (usage && usage.provider === provider) {
+      if (usage && usage.provider === provider2) {
         latest = usage;
       }
       continue;
     }
-    if (provider === "codex") {
+    if (provider2 === "codex") {
       const usage = codexTokenCountToContextUsage(event);
       if (usage) {
         latest = usage;
@@ -7530,7 +7671,7 @@ function normalizeSlashCommandName(name) {
   if (!command || /\s/.test(command)) return null;
   return `/${command}`;
 }
-function createProviderSlashCommand(provider, name, description, argumentHint) {
+function createProviderSlashCommand(provider2, name, description, argumentHint) {
   const command = normalizeSlashCommandName(name);
   if (!command) return null;
   const trimmedDescription = description?.trim();
@@ -7539,7 +7680,7 @@ function createProviderSlashCommand(provider, name, description, argumentHint) {
     command,
     description: trimmedDescription || `Run ${command}.`,
     ...trimmedArgumentHint ? { argumentHint: trimmedArgumentHint } : {},
-    providers: [provider]
+    providers: [provider2]
   };
 }
 var SIDE_CHAT_COMMANDS = ["/btw", "/side"];
@@ -7596,8 +7737,8 @@ function mergeSlashCommands(...commandGroups) {
   }
   return commands;
 }
-function getSlashCommandsForProvider(provider, commands = SLASH_COMMANDS) {
-  return commands.filter((command) => command.providers.includes(provider));
+function getSlashCommandsForProvider(provider2, commands = SLASH_COMMANDS) {
+  return commands.filter((command) => command.providers.includes(provider2));
 }
 var MAX_CODEX_GOAL_OBJECTIVE_CHARS = 4e3;
 function classifyGoalValue(value) {
@@ -7606,20 +7747,20 @@ function classifyGoalValue(value) {
   if (/^resume$/i.test(value)) return { type: "resume" };
   return { type: "set", objective: value };
 }
-function parseGoalCommand(message) {
-  const match = message.trim().match(/^\/goal(?:\s+([\s\S]*))?$/i);
+function parseGoalCommand(message2) {
+  const match = message2.trim().match(/^\/goal(?:\s+([\s\S]*))?$/i);
   const value = match?.[1]?.trim();
   if (!value) return null;
   return classifyGoalValue(value);
 }
-function getGoalCommand(message, goalMode) {
-  if (!goalMode) return parseGoalCommand(message);
-  const value = message.trim();
+function getGoalCommand(message2, goalMode) {
+  if (!goalMode) return parseGoalCommand(message2);
+  const value = message2.trim();
   if (!value) return null;
   return classifyGoalValue(value);
 }
-function getGoalCommandObjectiveValidationError(message, goalMode) {
-  const command = getGoalCommand(message, goalMode);
+function getGoalCommandObjectiveValidationError(message2, goalMode) {
+  const command = getGoalCommand(message2, goalMode);
   if (command?.type !== "set") return null;
   const length = command.objective.length;
   if (length <= MAX_CODEX_GOAL_OBJECTIVE_CHARS) return null;
@@ -7997,7 +8138,7 @@ var CLAUDE_AUTH_ENV_KEYS_BY_METHOD = {
 };
 
 // ../shared/src/routes/command-protection.ts
-import { z as z13 } from "zod";
+import { z as z15 } 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"]);
@@ -8088,27 +8229,27 @@ function findCheckoutTarget(args) {
 }
 
 // ../shared/src/routes/command-protection.ts
-var commandProtectionRepoStateSchema = z13.object({
-  branch: z13.string().nullable(),
-  defaultBranch: z13.string().nullable(),
-  pushBranch: z13.string().nullable(),
-  pushConfig: z13.string().nullable(),
-  headMessage: z13.string().nullable(),
-  mergeInProgress: z13.boolean().optional()
+var commandProtectionRepoStateSchema = z15.object({
+  branch: z15.string().nullable(),
+  defaultBranch: z15.string().nullable(),
+  pushBranch: z15.string().nullable(),
+  pushConfig: z15.string().nullable(),
+  headMessage: z15.string().nullable(),
+  mergeInProgress: z15.boolean().optional()
 });
-var commandProtectionEvaluateRequestSchema = z13.object({
-  provider: z13.enum(["claude", "codex", "cursor", "opencode", "pi"]),
-  source: z13.enum(["claude_pre_tool_use", "codex_approval_request", "cursor_pre_tool_use", "opencode_pre_tool_use", "pi_tool_call"]),
-  toolName: z13.string(),
-  toolInput: z13.unknown(),
-  command: z13.string().nullish(),
-  cwd: z13.string().nullish(),
-  toolUseId: z13.string().nullish(),
+var commandProtectionEvaluateRequestSchema = z15.object({
+  provider: z15.enum(["claude", "codex", "cursor", "opencode", "pi"]),
+  source: z15.enum(["claude_pre_tool_use", "codex_approval_request", "cursor_pre_tool_use", "opencode_pre_tool_use", "pi_tool_call"]),
+  toolName: z15.string(),
+  toolInput: z15.unknown(),
+  command: z15.string().nullish(),
+  cwd: z15.string().nullish(),
+  toolUseId: z15.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: z13.object({
-    repos: z13.record(z13.string(), commandProtectionRepoStateSchema),
-    messageFiles: z13.record(z13.string(), z13.string())
+  gitContext: z15.object({
+    repos: z15.record(z15.string(), commandProtectionRepoStateSchema),
+    messageFiles: z15.record(z15.string(), z15.string())
   }).optional()
 });
 var COMMAND_PROTECTION_COMMAND_KEYS = ["command", "cmd", "script", "query", "endpoint", "path", "url", "mutation"];
@@ -8305,89 +8446,89 @@ function shouldRefreshPullRequests(toolName, toolInput) {
 }
 
 // ../shared/src/routes/linear.ts
-import { z as z14 } from "zod";
-var linearSessionMetadataSchema = z14.object({
-  via_mothership: z14.boolean().optional(),
-  issue_id: z14.string(),
-  issue_identifier: z14.string(),
-  issue_title: z14.string(),
-  issue_description: z14.string(),
-  issue_url: z14.string(),
-  comment_id: z14.string(),
-  comment_body: z14.string(),
-  triggered_by_id: z14.string().optional(),
-  triggered_by_name: z14.string().optional(),
-  triggered_by_email: z14.string().optional(),
-  linear_workspace_id: z14.string().optional(),
-  creator_id: z14.string().optional(),
-  creator_name: z14.string().optional(),
-  creator_email: z14.string().optional(),
-  assignee_id: z14.string().optional(),
-  assignee_name: z14.string().optional(),
-  assignee_email: z14.string().optional(),
-  issue_state: z14.string().optional(),
-  parent_issue: z14.object({
-    id: z14.string(),
-    identifier: z14.string(),
-    title: z14.string(),
-    description: z14.string().nullable()
+import { z as z16 } from "zod";
+var linearSessionMetadataSchema = z16.object({
+  via_mothership: z16.boolean().optional(),
+  issue_id: z16.string(),
+  issue_identifier: z16.string(),
+  issue_title: z16.string(),
+  issue_description: z16.string(),
+  issue_url: z16.string(),
+  comment_id: z16.string(),
+  comment_body: z16.string(),
+  triggered_by_id: z16.string().optional(),
+  triggered_by_name: z16.string().optional(),
+  triggered_by_email: z16.string().optional(),
+  linear_workspace_id: z16.string().optional(),
+  creator_id: z16.string().optional(),
+  creator_name: z16.string().optional(),
+  creator_email: z16.string().optional(),
+  assignee_id: z16.string().optional(),
+  assignee_name: z16.string().optional(),
+  assignee_email: z16.string().optional(),
+  issue_state: z16.string().optional(),
+  parent_issue: z16.object({
+    id: z16.string(),
+    identifier: z16.string(),
+    title: z16.string(),
+    description: z16.string().nullable()
   }).optional(),
-  workspace: z14.object({
-    id: z14.string(),
-    coding_agent: z14.custom((value) => typeof value === "string" && isValidAgentProvider(value)),
-    task_description: z14.string(),
-    created_at: z14.string()
+  workspace: z16.object({
+    id: z16.string(),
+    coding_agent: z16.custom((value) => typeof value === "string" && isValidAgentProvider(value)),
+    task_description: z16.string(),
+    created_at: z16.string()
   }).optional()
 });
 
 // ../shared/src/routes/mothership.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var MOTHERSHIP_LINEAR_ACTIONS = ["ask", "start"];
-var mothershipLinearSessionIntentRequestSchema = z15.object({
-  comment_id: z15.string().trim().min(1).describe("Id of the Linear comment the session will be created on."),
-  action: z15.enum(MOTHERSHIP_LINEAR_ACTIONS).describe("`ask` when the comment is a clarifying question, `start` when it is the complete task prompt.")
+var mothershipLinearSessionIntentRequestSchema = z17.object({
+  comment_id: z17.string().trim().min(1).describe("Id of the Linear comment the session will be created on."),
+  action: z17.enum(MOTHERSHIP_LINEAR_ACTIONS).describe("`ask` when the comment is a clarifying question, `start` when it is the complete task prompt.")
 });
-var mothershipLinearStartRequestSchema = z15.object({
-  issue_id: z15.string().describe("Linear issue id from the envelope's `issue_id`."),
-  agent_session_id: z15.string().describe("Existing Linear agent session id from the envelope's `agent_session_id`."),
-  prompt: z15.string().trim().min(1).describe("Complete task prompt for the coding workspace.")
+var mothershipLinearStartRequestSchema = z17.object({
+  issue_id: z17.string().describe("Linear issue id from the envelope's `issue_id`."),
+  agent_session_id: z17.string().describe("Existing Linear agent session id from the envelope's `agent_session_id`."),
+  prompt: z17.string().trim().min(1).describe("Complete task prompt for the coding workspace.")
 });
-var slackChannelIdSchema = z15.string().describe("Slack channel id from the envelope's `channel_id`.");
-var slackThreadTsSchema = z15.string().describe("Slack thread timestamp from the envelope's `thread_ts`.");
-var mothershipSlackSpawnRequestSchema = z15.object({
+var slackChannelIdSchema = z17.string().describe("Slack channel id from the envelope's `channel_id`.");
+var slackThreadTsSchema = z17.string().describe("Slack thread timestamp from the envelope's `thread_ts`.");
+var mothershipSlackSpawnRequestSchema = z17.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message_ts: z15.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: z15.string().describe("Slack user id of that message's author (the envelope's `user_id`). The workspace is attributed to them."),
-  prompt: z15.string().describe("Complete task for the new workspace, written so it stands on its own."),
-  environment_id: z15.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: z17.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: z17.string().describe("Slack user id of that message's author (the envelope's `user_id`). The workspace is attributed to them."),
+  prompt: z17.string().describe("Complete task for the new workspace, written so it stands on its own."),
+  environment_id: z17.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 mothershipSlackRelayRequestSchema = z15.object({
+var mothershipSlackRelayRequestSchema = z17.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message: z15.string().describe("The follow-up to deliver, combining every fresh message that belongs to this update."),
-  user_id: z15.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."),
-  queue: z15.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.")
+  message: z17.string().describe("The follow-up to deliver, combining every fresh message that belongs to this update."),
+  user_id: z17.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."),
+  queue: z17.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.")
 });
-var mothershipSlackConfirmationSchema = z15.object({
-  confirmation_channel_id: z15.string().describe("`channel_id` from the envelope of the Slack message that asked for or accepted this."),
-  confirmation_thread_ts: z15.string().describe("`thread_ts` from that message's envelope."),
-  confirmation_message_ts: z15.string().describe("`message_ts` from that message's envelope."),
-  confirmation_user_id: z15.string().describe("`user_id` from that message's envelope.")
+var mothershipSlackConfirmationSchema = z17.object({
+  confirmation_channel_id: z17.string().describe("`channel_id` from the envelope of the Slack message that asked for or accepted this."),
+  confirmation_thread_ts: z17.string().describe("`thread_ts` from that message's envelope."),
+  confirmation_message_ts: z17.string().describe("`message_ts` from that message's envelope."),
+  confirmation_user_id: z17.string().describe("`user_id` from that message's envelope.")
 });
 var mothershipAutomationToolInputSchema = automationToolInputSchema.extend(mothershipSlackConfirmationSchema.shape);
 var mothershipSaveChannelPresetToolInputSchema = mothershipSlackConfirmationSchema.extend({
-  preset_id: z15.string().optional().describe(`Id of the preset to update, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`. Omit to create a new preset.`),
-  name: z15.string().trim().min(1).max(MOTHERSHIP_PRESET_NAME_MAX_LENGTH).optional().describe("Preset name. Required when creating."),
-  description: z15.string().optional().describe("One-line summary shown in settings."),
-  icon: z15.enum(MOTHERSHIP_PRESET_ICONS).optional(),
-  instructions: z15.string().optional().describe("Complete preset instructions; replaces the existing text. Required when creating.")
+  preset_id: z17.string().optional().describe(`Id of the preset to update, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`. Omit to create a new preset.`),
+  name: z17.string().trim().min(1).max(MOTHERSHIP_PRESET_NAME_MAX_LENGTH).optional().describe("Preset name. Required when creating."),
+  description: z17.string().optional().describe("One-line summary shown in settings."),
+  icon: z17.enum(MOTHERSHIP_PRESET_ICONS).optional(),
+  instructions: z17.string().optional().describe("Complete preset instructions; replaces the existing text. Required when creating.")
 });
 var mothershipUpdateChannelSettingsToolInputSchema = mothershipSlackConfirmationSchema.extend({
-  source: z15.enum(MOTHERSHIP_SOURCE_TYPES).optional().describe("Defaults to `slack`."),
-  external_id: z15.string().describe(`Slack channel id or Linear team id of an already monitored source, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`.`),
-  preset_id: z15.string().nullable().optional().describe("Preset to assign; `null` removes the preset. Omit to keep it."),
-  instructions: z15.string().nullable().optional().describe("Complete channel-specific instructions, applied after the preset; replaces the existing text. `null` clears them. Omit to keep them.")
+  source: z17.enum(MOTHERSHIP_SOURCE_TYPES).optional().describe("Defaults to `slack`."),
+  external_id: z17.string().describe(`Slack channel id or Linear team id of an already monitored source, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`.`),
+  preset_id: z17.string().nullable().optional().describe("Preset to assign; `null` removes the preset. Omit to keep it."),
+  instructions: z17.string().nullable().optional().describe("Complete channel-specific instructions, applied after the preset; replaces the existing text. `null` clears them. Omit to keep them.")
 });
 
 // ../shared/src/routes/plugin-catalog.ts
@@ -8711,85 +8852,46 @@ var workspaceLastViewedAtClientStateKey = orgUserClientStateKey(WORKSPACE_LAST_V
 var workspaceAttentionDoneClientStateKey = orgUserClientStateKey(WORKSPACE_ATTENTION_DONE_CLIENT_STATE_KEY_PREFIX);
 var workspaceStagesClientStateKey = orgUserClientStateKey(WORKSPACE_STAGES_CLIENT_STATE_KEY_PREFIX);
 
-// ../shared/src/routes/workspaces.ts
-import { z as z16 } 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);
-var WORKSPACE_SORT_CHOICES = [
-  ["manual", "Custom"],
-  ["activity", "Last activity"],
-  ["created", "Created date"]
-];
-var WORKSPACE_SORT_OPTIONS = WORKSPACE_SORT_CHOICES.map(([option]) => option);
-var WORKSPACE_SORT_LABELS = Object.fromEntries(WORKSPACE_SORT_CHOICES);
-var WORKSPACE_SIDEBAR_ORGANIZATION_CHOICES = [
-  ["chronological", "Chronological"],
-  ["environments", "Environments"],
-  ["recent", "Recent environments"]
-];
-var WORKSPACE_SIDEBAR_ORGANIZATIONS = WORKSPACE_SIDEBAR_ORGANIZATION_CHOICES.map(([organization]) => organization);
-var WORKSPACE_SIDEBAR_ORGANIZATION_LABELS = Object.fromEntries(WORKSPACE_SIDEBAR_ORGANIZATION_CHOICES);
-var DEFAULT_STATUS_FILTERS = [...WORKSPACE_STATUS_FILTERS];
-var DEFAULT_WORKSPACE_FILTERS = {
-  statuses: [...DEFAULT_STATUS_FILTERS],
-  ownerIds: [],
-  activity: "any"
-};
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
-var workspaceExecRequestSchema = z16.object({
-  command: z16.string().regex(/\S/, "command is required"),
-  timeout_seconds: z16.number().int().min(1).max(50).optional().describe("Default: 30")
-});
-var terminalRtcCandidateSchema = z16.object({ type: z16.literal("rtc-candidate"), candidate: z16.string(), mid: z16.string() });
-var terminalSocketServerMessageSchema = z16.discriminatedUnion("type", [
-  z16.object({ type: z16.literal("output"), data: z16.string() }),
-  z16.object({ type: z16.literal("rtc-answer"), sdp: z16.string() }),
-  terminalRtcCandidateSchema,
-  z16.object({ type: z16.literal("rtc-switch") })
-]);
-var TERMINAL_RTC_ICE_SERVER = "stun:stun.l.google.com:19302";
-
 // ../shared/src/routes/workspace-events.ts
-import { z as z17 } from "zod";
-var workspaceChangedEventSchema = z17.discriminatedUnion("type", [
-  z17.object({
-    type: z17.literal("workspace.changed"),
-    workspaceId: z17.string(),
-    completion: z17.object({
-      workspaceName: z17.string(),
-      completedAt: z17.string(),
-      processing: z17.boolean().optional()
+import { z as z18 } from "zod";
+var workspaceChangedEventSchema = z18.discriminatedUnion("type", [
+  z18.object({
+    type: z18.literal("workspace.changed"),
+    workspaceId: z18.string(),
+    completion: z18.object({
+      workspaceName: z18.string(),
+      completedAt: z18.string(),
+      processing: z18.boolean().optional()
     }).optional(),
-    ts: z17.string()
+    ts: z18.string()
   }),
-  z17.object({
-    type: z17.literal("workspace.chat.changed"),
-    workspaceId: z17.string(),
-    chatId: z17.string(),
-    ts: z17.string()
+  z18.object({
+    type: z18.literal("workspace.chat.changed"),
+    workspaceId: z18.string(),
+    chatId: z18.string(),
+    ts: z18.string()
   }),
-  z17.object({ type: z17.literal("presence.changed"), ts: z17.string() }),
-  z17.object({
-    type: z17.literal("mobile-testing.changed"),
-    workspaceId: z17.string(),
-    ts: z17.string()
+  z18.object({ type: z18.literal("presence.changed"), ts: z18.string() }),
+  z18.object({
+    type: z18.literal("mobile-testing.changed"),
+    workspaceId: z18.string(),
+    ts: z18.string()
   })
 ]);
 
 // ../shared/src/routes/presence.ts
-import { z as z18 } from "zod";
-var presenceStatusSchema = z18.enum(["online", "typing"]);
-var presenceLocationSchema = z18.object({
-  workspaceId: z18.string().optional()
+import { z as z19 } from "zod";
+var presenceStatusSchema = z19.enum(["online", "typing"]);
+var presenceLocationSchema = z19.object({
+  workspaceId: z19.string().optional()
 });
-var presenceEntrySchema = z18.object({
-  userId: z18.string(),
+var presenceEntrySchema = z19.object({
+  userId: z19.string(),
   status: presenceStatusSchema,
   location: presenceLocationSchema,
-  ts: z18.string()
+  ts: z19.string()
 });
-var updatePresenceRequestSchema = z18.object({
+var updatePresenceRequestSchema = z19.object({
   status: presenceStatusSchema,
   location: presenceLocationSchema.optional()
 });
@@ -8864,20 +8966,6 @@ function scoreRepoFileMatch(query, filePath) {
 var WEBHOOK_PROVIDERS = ["linear", "github", "gitlab", "slack", "e2b", "stripe", "sentry"];
 var WEBHOOK_PROVIDER_SET = new Set(WEBHOOK_PROVIDERS);
 
-// ../shared/src/routes/environment.ts
-import { z as z19 } from "zod";
-var ENVIRONMENT_MCP_TRANSPORTS = ["stdio", "http", "sse"];
-var stringMap = z19.record(z19.string(), z19.string());
-var createEnvironmentMcpRequestSchema = z19.object({
-  name: z19.string(),
-  transport: z19.enum(ENVIRONMENT_MCP_TRANSPORTS),
-  config: z19.union([
-    z19.object({ command: z19.string().min(1), args: z19.array(z19.string()).optional(), env: stringMap.optional() }),
-    z19.object({ url: z19.url(), headers: stringMap.optional(), auth: mcpWorkloadAuthSchema.optional() })
-  ]).describe("stdio: `{ command, args, env }`. http/sse: `{ url, headers }`.")
-});
-var updateEnvironmentMcpRequestSchema = createEnvironmentMcpRequestSchema.partial();
-
 // ../shared/src/workspace-sidebar-state.ts
 var FIRST_BOOT_GRACE_MS = 15 * 6e4;
 var SLOW_ENGINE_GRACE_MS = 10 * 6e4;
@@ -9023,12 +9111,12 @@ function normalizeChatTranscriptMetadata(value) {
   if (!isRecord(value)) return {};
   const metadata = {};
   const {
-    provider,
+    provider: provider2,
     credential,
     credentialSource,
     environmentAuthMethod,
-    model,
-    title,
+    model: model2,
+    title: title2,
     displayName,
     createdAt,
     updatedAt,
@@ -9042,14 +9130,14 @@ function normalizeChatTranscriptMetadata(value) {
     sha256,
     fork
   } = value;
-  if (typeof provider === "string" && isValidAgentProvider(provider)) metadata.provider = provider;
+  if (typeof provider2 === "string" && isValidAgentProvider(provider2)) metadata.provider = provider2;
   const parsedCredential = agentCredentialSnapshotSchema.safeParse(credential);
   if (parsedCredential.success) metadata.credential = parsedCredential.data;
   if (credentialSource === "stored" || credentialSource === "environment") metadata.credentialSource = credentialSource;
   const authMethod = Object.values(CREDENTIAL_METHOD).find((method) => method === environmentAuthMethod);
   if (authMethod) metadata.environmentAuthMethod = authMethod;
-  if (typeof model === "string") metadata.model = model;
-  if (typeof title === "string") metadata.title = title;
+  if (typeof model2 === "string") metadata.model = model2;
+  if (typeof title2 === "string") metadata.title = title2;
   if (typeof displayName === "string") metadata.displayName = displayName;
   if (typeof createdAt === "string") metadata.createdAt = createdAt;
   if (typeof updatedAt === "string") metadata.updatedAt = updatedAt;
@@ -9249,15 +9337,28 @@ export {
   paginateChatHistory,
   coerceBackgroundTaskPayload,
   fileContentDiff,
+  skillNamesFromCommand,
   areUserMessagesWithinMatchWindow,
   isGitHubUrl,
   parseCodeHostPrUrl,
   decodePathSegments,
   buildCodeHostPrUrl,
   createUuidFromHex,
+  SUBAGENT_MCP_SERVER_NAME,
+  SUBAGENT_MCP_TOOLS,
+  SUBAGENT_MCP_TOOL_NAMES,
+  WORKSPACE_IDENTITY_AUDIENCE,
+  AWS_SOURCE_IDENTITY_CLAIM,
+  IDENTITY_PROXY_PORT,
+  IDENTITY_TOKEN_PATH,
+  workspaceAudienceSchema,
+  workspaceTokenRequestSchema,
+  workspaceTokenResponseSchema,
+  legacyWorkspaceTokenBundleSchema,
   SANDBOX_SKILL_DIRS,
   HISTORY_ROOT,
   HISTORY_INDEX_FILENAME,
+  TERMINAL_RTC_ICE_SERVER,
   REPLICAS_INSTRUCTIONS_TAG,
   wrapInTag,
   extractErrorText,
@@ -9322,9 +9423,6 @@ export {
   resolveWarmHookConfig,
   REPLICAS_CONFIG_FILENAMES,
   parseReplicasConfigString,
-  SUBAGENT_MCP_SERVER_NAME,
-  SUBAGENT_MCP_TOOLS,
-  SUBAGENT_MCP_TOOL_NAMES,
   headlessAgentRequestSchema,
   isClaudeAuthErrorText,
   isCodexAuthError,
@@ -9344,18 +9442,9 @@ export {
   findGitCommitSignals,
   findCommandProtectionGitLookups,
   shouldRefreshPullRequests,
-  TERMINAL_RTC_ICE_SERVER,
   MAX_REPO_FILE_CONTENT_BYTES,
   searchRepoFileIndex,
   isExcludedRepoFilePath,
-  WORKSPACE_IDENTITY_AUDIENCE,
-  AWS_SOURCE_IDENTITY_CLAIM,
-  IDENTITY_PROXY_PORT,
-  IDENTITY_TOKEN_PATH,
-  workspaceAudienceSchema,
-  workspaceTokenRequestSchema,
-  workspaceTokenResponseSchema,
-  legacyWorkspaceTokenBundleSchema,
   readJsonlPage,
   normalizeChatTranscriptMetadata,
   parseChatTranscriptArtifact,