replicas-engine 0.1.1350 → 0.1.1352

package/dist/src/{chunk-HCSEZ4G6.js → chunk-KQXHQH5H.js}

@@ -1116,17 +1116,17 @@ var require_luxon = __commonJS({
       constructor(dt, intl, opts) {
         this.opts = opts;
         this.originalZone = void 0;
-        let z29 = void 0;
+        let z30 = void 0;
         if (this.opts.timeZone) {
           this.dt = dt;
         } else if (dt.zone.type === "fixed") {
           const gmtOffset = -1 * (dt.offset / 60);
           const offsetZ = gmtOffset >= 0 ? `Etc/GMT+${gmtOffset}` : `Etc/GMT${gmtOffset}`;
           if (dt.offset !== 0 && IANAZone.create(offsetZ).valid) {
-            z29 = offsetZ;
+            z30 = offsetZ;
             this.dt = dt;
           } else {
-            z29 = "UTC";
+            z30 = "UTC";
             this.dt = dt.offset === 0 ? dt : dt.setZone("UTC").plus({
               minutes: dt.offset
             });
@@ -1136,9 +1136,9 @@ var require_luxon = __commonJS({
           this.dt = dt;
         } else if (dt.zone.type === "iana") {
           this.dt = dt;
-          z29 = dt.zone.name;
+          z30 = dt.zone.name;
         } else {
-          z29 = "UTC";
+          z30 = "UTC";
           this.dt = dt.setZone("UTC").plus({
             minutes: dt.offset
           });
@@ -1147,7 +1147,7 @@ var require_luxon = __commonJS({
         const intlOpts = {
           ...this.opts
         };
-        intlOpts.timeZone = intlOpts.timeZone || z29;
+        intlOpts.timeZone = intlOpts.timeZone || z30;
         this.dtf = getCachedDTF(intl, intlOpts);
       }
       format() {
@@ -11019,6 +11019,10 @@ var sendChatMessageResponseSchema = z4.object({
   chatId: z4.string().optional(),
   steered: z4.boolean().optional()
 });
+var respondToolInputRequestSchema = z4.object({
+  requestId: z4.string().min(1),
+  selectionId: z4.string().min(1)
+});
 function isLatestChatHistoryPage(params) {
   return params.beforeCursor === void 0 && params.beforeEvent === void 0 && params.beforeTurn === void 0;
 }
@@ -11087,6 +11091,12 @@ var SUBAGENT_MCP_TOOLS = {
   deleteAgent: "delete_agent"
 };
 var SUBAGENT_MCP_TOOL_NAMES = Object.values(SUBAGENT_MCP_TOOLS);
+function isSubagentMcpToolName(tool) {
+  return SUBAGENT_MCP_TOOL_NAMES.some((name) => name === tool);
+}
+function isSubagentMcpServerName(server) {
+  return server === SUBAGENT_MCP_SERVER_NAME;
+}
 
 // ../shared/src/workspace-identity.ts
 import { z as z5 } from "zod";
@@ -11619,7 +11629,7 @@ var reorderCredentialPoolSchema = z13.object({
 });
 
 // ../shared/src/mothership-events.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // ../shared/src/replicas-mcp.ts
 import { z as z17 } from "zod";
@@ -11734,6 +11744,7 @@ var terminalSocketServerMessageSchema = z16.discriminatedUnion("type", [
 var TERMINAL_RTC_ICE_SERVER = "stun:stun.l.google.com:19302";
 
 // ../shared/src/replicas-mcp.ts
+var REPLICAS_MCP_SERVER_NAME = "replicas-mcp";
 var REPLICAS_MCP_TOOLS = {
   listEnvironments: "list_environments",
   createAutomation: "create_automation",
@@ -11846,6 +11857,54 @@ var SCOUT_PRESET_ICONS = [
   "tag"
 ];
 
+// ../shared/src/routes/push.ts
+import { z as z18 } from "zod";
+
+// ../shared/src/workspace-attention.ts
+var WORKSPACE_ATTENTION_REASONS = ["question", "plan", "variables", "blocked", "setup"];
+var CHAT_ATTENTION_REASONS = ["question", "blocked"];
+
+// ../shared/src/routes/push.ts
+var registerPushDeviceRequestSchema = z18.discriminatedUnion("platform", [
+  z18.object({
+    platform: z18.literal("ios"),
+    token: z18.string().regex(/^[0-9a-f]{64,200}$/i),
+    appId: z18.string().min(1).max(255),
+    apnsEnvironment: z18.enum(["sandbox", "production"])
+  }),
+  z18.object({
+    platform: z18.literal("android"),
+    token: z18.string().min(1).max(4096),
+    appId: z18.string().min(1).max(255)
+  })
+]);
+var PUSH_HOLD_MINUTES = 5;
+var recordPushActivityRequestSchema = z18.object({
+  organizationId: z18.string().uuid(),
+  /** Seconds since the last keyboard or mouse input on this computer. A phone leaves it out: it only reports what it has open. */
+  idleSeconds: z18.number().min(0).optional(),
+  seenWorkspaceIds: z18.array(z18.string().uuid()).max(20)
+});
+var PUSH_NOTIFICATION_KINDS = [...WORKSPACE_ATTENTION_REASONS, "finished", "pull_request"];
+var pushQuestionSchema = z18.object({ id: z18.string().max(64), options: z18.array(z18.object({ id: z18.string().max(64), label: z18.string().min(1).max(60) })).min(1).max(4) });
+var pushNotificationDataSchema = z18.object({
+  organizationId: z18.string(),
+  workspaceId: z18.string(),
+  chatId: z18.string().nullable(),
+  kind: z18.enum(PUSH_NOTIFICATION_KINDS),
+  completedAt: z18.string(),
+  pullRequestUrl: z18.string().optional(),
+  toolRequestId: z18.string().optional(),
+  question: pushQuestionSchema.optional()
+});
+var registerLiveActivityRequestSchema = z18.object({
+  deviceId: z18.string().uuid(),
+  workspaceId: z18.string().uuid(),
+  chatId: z18.string().min(1).max(100),
+  /** The iOS activity's push token. Android leaves it out and gets FCM data messages on the device token. */
+  pushToken: z18.string().regex(/^[0-9a-f]{64,400}$/i).optional()
+});
+
 // ../shared/src/default-skills/replicas-agent/abilities/computer.ts
 var SECTION = `### Computer use (Linux desktop control)
 Drive the workspace's Linux desktop - open a browser, click, type, scroll, screenshot, record - via the \`replicas computer\` CLI. Every Replicas workspace boots with a live H.264 and Opus stream published as an authenticated preview, so a \`Desktop\` tab is always available in the dashboard. Use \`replicas computer info\` to get the viewer URL when you want to share it (e.g. point a user on Slack at the live stream).
@@ -12125,7 +12184,7 @@ var DOCKER_ABILITY = {
 };
 
 // ../shared/src/routes/environment-setups.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 var ENVIRONMENT_SETUP_STEPS = [
   { key: "understand", label: "Understand the codebase" },
   { key: "install", label: "Install dependencies and run the app" },
@@ -12158,17 +12217,17 @@ var ENVIRONMENT_SETUP_LIMITS = {
   repositories: 20
 };
 var VARIABLE_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var text2 = (max) => max === void 0 ? z18.string().trim() : z18.string().trim().max(max);
+var text2 = (max) => max === void 0 ? z19.string().trim() : z19.string().trim().max(max);
 var requiredText = (max) => text2(max).min(1, "must not be empty");
 var optionalText2 = (max) => text2(max).nullish().transform((value) => value || null);
 var clearableText = (max) => text2(max).nullish().transform((value) => value === void 0 ? void 0 : value || null);
-var list = (item, max) => max === void 0 ? z18.array(item) : z18.array(item).max(max);
+var list = (item, max) => max === void 0 ? z19.array(item) : z19.array(item).max(max);
 var ENVIRONMENT_SETUP_AUTHORED_TRIGGER_TYPES = ["cron", "github", "gitlab"];
 function isEnvironmentSetupAuthoredTriggerType(type) {
   return ENVIRONMENT_SETUP_AUTHORED_TRIGGER_TYPES.some((authored) => authored === type);
 }
-var proposalTriggerSchema = z18.discriminatedUnion("type", [cronTriggerSchema, githubTriggerSchema, gitlabTriggerSchema]);
-var existingTriggerSchema = z18.custom(
+var proposalTriggerSchema = z19.discriminatedUnion("type", [cronTriggerSchema, githubTriggerSchema, gitlabTriggerSchema]);
+var existingTriggerSchema = z19.custom(
   (value) => isRecord(value) && typeof value.type === "string" && isRecord(value.config),
   "must be an automation trigger"
 );
@@ -12176,17 +12235,17 @@ var carriedTriggerSchema = existingTriggerSchema.refine(
   (trigger) => !isEnvironmentSetupAuthoredTriggerType(trigger.type)
 );
 function automationSchema(limits) {
-  const authored = z18.object({
+  const authored = z19.object({
     name: text2(limits.nameChars),
     description: text2(limits.descriptionChars),
     prompt: text2(limits.automationPromptChars),
     triggers: list(proposalTriggerSchema, limits.automationTriggers)
   });
-  const updated = authored.extend({ triggers: list(z18.union([proposalTriggerSchema, carriedTriggerSchema]), limits.automationTriggers) });
-  return z18.object({
+  const updated = authored.extend({ triggers: list(z19.union([proposalTriggerSchema, carriedTriggerSchema]), limits.automationTriggers) });
+  return z19.object({
     key: requiredText(limits.automationKeyChars),
-    action: z18.enum(ENVIRONMENT_SETUP_AUTOMATION_ACTIONS).default("create"),
-    automation_id: z18.string().regex(UUID_RE, "must be an automation id").nullable().default(null),
+    action: z19.enum(ENVIRONMENT_SETUP_AUTOMATION_ACTIONS).default("create"),
+    automation_id: z19.string().regex(UUID_RE, "must be an automation id").nullable().default(null),
     name: text2().default(""),
     description: optionalText2().transform((value) => value ?? ""),
     prompt: text2().default(""),
@@ -12209,7 +12268,7 @@ function automationSchema(limits) {
     const content = (automation.action === "update" ? updated : authored).safeParse(automation);
     if (content.success) return { ...automation, ...content.data };
     for (const issue of content.error.issues) ctx.addIssue({ ...issue, code: "custom" });
-    return z18.NEVER;
+    return z19.NEVER;
   });
 }
 function automationListSchema(limits) {
@@ -12227,7 +12286,7 @@ function automationListSchema(limits) {
   });
 }
 function environmentSchema(limits) {
-  return z18.object({
+  return z19.object({
     name: optionalText2(limits.nameChars).transform((value) => value ?? void 0),
     description: clearableText(limits.descriptionChars),
     system_prompt: clearableText(limits.systemPromptChars),
@@ -12236,41 +12295,41 @@ function environmentSchema(limits) {
   });
 }
 function proposalSchema(limits) {
-  return z18.object({
+  return z19.object({
     summary: requiredText(limits.summaryChars),
     stack: list(text2(), limits.stackItems).default([]).transform((items) => items.filter(Boolean)),
     environment: environmentSchema(limits),
-    variables: list(z18.object({
-      key: z18.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(limits.variableKeyChars ?? Number.POSITIVE_INFINITY),
+    variables: list(z19.object({
+      key: z19.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(limits.variableKeyChars ?? Number.POSITIVE_INFINITY),
       description: optionalText2(limits.variableDescriptionChars).transform((value) => value ?? ""),
-      required: z18.boolean().default(false)
+      required: z19.boolean().default(false)
     }), limits.variables).default([]),
     automations: automationListSchema(limits),
-    verification: list(z18.object({
+    verification: list(z19.object({
       label: requiredText(limits.nameChars),
-      status: z18.enum(ENVIRONMENT_SETUP_VERIFICATION_STATUSES),
+      status: z19.enum(ENVIRONMENT_SETUP_VERIFICATION_STATUSES),
       detail: optionalText2(limits.verificationDetailChars).transform((value) => value ?? void 0)
     }), limits.verificationItems).default([]),
-    media: list(z18.object({
-      media_id: z18.string().regex(UUID_RE, "must be a media id"),
+    media: list(z19.object({
+      media_id: z19.string().regex(UUID_RE, "must be a media id"),
       title: requiredText(limits.nameChars)
     }), limits.mediaItems).default([])
   });
 }
 var environmentSetupProposalSchema = proposalSchema({});
 var environmentSetupProposalSubmissionSchema = proposalSchema(ENVIRONMENT_SETUP_LIMITS);
-var environmentSetupRunStateSchema = z18.object({
-  status: z18.enum(ENVIRONMENT_SETUP_RUN_STATUSES),
-  steps: z18.partialRecord(z18.enum(ENVIRONMENT_SETUP_STEPS.map((step) => step.key)), z18.enum(ENVIRONMENT_SETUP_STEP_STATUSES)).default({}),
+var environmentSetupRunStateSchema = z19.object({
+  status: z19.enum(ENVIRONMENT_SETUP_RUN_STATUSES),
+  steps: z19.partialRecord(z19.enum(ENVIRONMENT_SETUP_STEPS.map((step) => step.key)), z19.enum(ENVIRONMENT_SETUP_STEP_STATUSES)).default({}),
   proposal: environmentSetupProposalSchema.nullable().default(null),
-  applied: z18.object({
-    applied_at: z18.string(),
-    automation_ids: z18.array(z18.string())
+  applied: z19.object({
+    applied_at: z19.string(),
+    automation_ids: z19.array(z19.string())
   }).nullable().default(null)
 });
-var applyEnvironmentSetupRequestSchema = z18.object({
+var applyEnvironmentSetupRequestSchema = z19.object({
   environment: environmentSchema(ENVIRONMENT_SETUP_LIMITS).extend({ name: requiredText(ENVIRONMENT_SETUP_LIMITS.nameChars) }),
-  variables: list(z18.object({ key: z18.string().regex(VARIABLE_KEY_RE), value: z18.string() }), ENVIRONMENT_SETUP_LIMITS.variables).default([]).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys").transform((variables) => variables.filter((variable) => variable.value.length > 0)),
+  variables: list(z19.object({ key: z19.string().regex(VARIABLE_KEY_RE), value: z19.string() }), ENVIRONMENT_SETUP_LIMITS.variables).default([]).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys").transform((variables) => variables.filter((variable) => variable.value.length > 0)),
   automations: automationListSchema(ENVIRONMENT_SETUP_LIMITS)
 });
 
@@ -12745,7 +12804,7 @@ var GITLAB_ABILITY = {
 };
 
 // ../shared/src/routes/compute.ts
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 var COMPUTE_SANDBOX_KINDS = ["gpu"];
 var GPU_TYPES = ["T4", "L4", "A10G", "L40S", "A100", "A100-80GB", "H100", "H200", "B200"];
 var DEFAULT_GPU_TYPE = "L4";
@@ -12762,27 +12821,27 @@ var COMPUTE_SANDBOX_LIMITS = {
   maxIdleTimeoutMinutes: 60,
   maxTransferBytes: 1024 ** 3
 };
-var computeEnvSchema = z19.record(z19.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z19.string().max(32768)).refine((env) => Object.keys(env).length <= 64, "At most 64 environment variables are allowed");
-var createComputeSandboxRequestSchema = z19.object({
-  kind: z19.enum(COMPUTE_SANDBOX_KINDS),
-  gpu: z19.string().trim().optional(),
-  image: z19.string().trim().min(1).max(256).regex(/^\S+$/, "Image must not contain whitespace").optional(),
-  timeoutMinutes: z19.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTimeoutMinutes).optional(),
-  idleTimeoutMinutes: z19.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxIdleTimeoutMinutes).optional(),
-  ports: z19.array(z19.number().int().min(1).max(65535)).max(COMPUTE_SANDBOX_LIMITS.maxPorts).optional(),
+var computeEnvSchema = z20.record(z20.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/).max(128), z20.string().max(32768)).refine((env) => Object.keys(env).length <= 64, "At most 64 environment variables are allowed");
+var createComputeSandboxRequestSchema = z20.object({
+  kind: z20.enum(COMPUTE_SANDBOX_KINDS),
+  gpu: z20.string().trim().optional(),
+  image: z20.string().trim().min(1).max(256).regex(/^\S+$/, "Image must not contain whitespace").optional(),
+  timeoutMinutes: z20.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTimeoutMinutes).optional(),
+  idleTimeoutMinutes: z20.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxIdleTimeoutMinutes).optional(),
+  ports: z20.array(z20.number().int().min(1).max(65535)).max(COMPUTE_SANDBOX_LIMITS.maxPorts).optional(),
   env: computeEnvSchema.optional()
 });
-var computeExecRequestSchema = z19.object({
-  command: z19.string().min(1).max(1e5),
-  workdir: z19.string().min(1).max(4096).optional(),
+var computeExecRequestSchema = z20.object({
+  command: z20.string().min(1).max(1e5),
+  workdir: z20.string().min(1).max(4096).optional(),
   env: computeEnvSchema.optional(),
-  detach: z19.boolean().optional()
+  detach: z20.boolean().optional()
 });
-var computeUploadRequestSchema = z19.object({
-  size: z19.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTransferBytes)
+var computeUploadRequestSchema = z20.object({
+  size: z20.number().int().min(1).max(COMPUTE_SANDBOX_LIMITS.maxTransferBytes)
 });
-var computeTransferPathSchema = z19.object({
-  path: z19.string().min(1).max(4096).optional()
+var computeTransferPathSchema = z20.object({
+  path: z20.string().min(1).max(4096).optional()
 });
 
 // ../shared/src/default-skills/replicas-agent/abilities/gpu.ts
@@ -14344,6 +14403,11 @@ var ALERT_SOUND_FAMILIES = {
   wood: ["ready", "pluck", "knock", "bloom", "steps"]
 };
 var ALERT_SOUNDS = [...ALERT_SOUND_FAMILIES.glass, ...ALERT_SOUND_FAMILIES.wood];
+var PUSH_WHEN_ACTIVE_COPY = {
+  wait: `Wait ${PUSH_HOLD_MINUTES} minutes`,
+  skip: "Don\u2019t send",
+  send: "Send right away"
+};
 var DEFAULT_USER_PREFERENCES = {
   default_agent: null,
   default_model: null,
@@ -14383,7 +14447,8 @@ var DEFAULT_USER_PREFERENCES = {
   alert_sound: null,
   workspace_alerts: {},
   automation_alerts: {},
-  push_types: { needs_you: true, finished: true, pull_requests: true, automations: true, usage_limit: true }
+  push_types: { needs_you: true, finished: true, pull_requests: true, automations: true, usage_limit: true },
+  push_when_active: "wait"
 };
 function defaultReplicasAgentAbilities() {
   const abilities = {};
@@ -14432,18 +14497,18 @@ var MOTHERSHIP_EVENT_KINDS = ["finished", "ready", "needs_attention", "merged",
 var MOTHERSHIP_TURN_ERROR_SUMMARY = "Turn ended with an error.";
 var MOTHERSHIP_EVENT_TYPE = "multitask-event";
 var MOTHERSHIP_EVENT_MESSAGE_TYPE = "multitask_event";
-var mothershipEventSchema = z20.object({
-  id: z20.string(),
-  at: z20.string(),
-  kind: z20.enum(MOTHERSHIP_EVENT_KINDS),
-  agentId: z20.string(),
-  agentName: z20.string(),
-  summary: z20.string(),
-  detail: z20.string().optional(),
+var mothershipEventSchema = z21.object({
+  id: z21.string(),
+  at: z21.string(),
+  kind: z21.enum(MOTHERSHIP_EVENT_KINDS),
+  agentId: z21.string(),
+  agentName: z21.string(),
+  summary: z21.string(),
+  detail: z21.string().optional(),
   // Set when the subagent is a chat in this workspace rather than a ship; agentId is then that chat's id.
-  chatId: z20.string().optional(),
+  chatId: z21.string().optional(),
   // Set on events recorded before every kind woke the orchestrator, which were shown as a row when they happened.
-  noticed: z20.boolean().optional()
+  noticed: z21.boolean().optional()
 });
 var TAG = "multitask_event";
 var BLOCK = new RegExp(`<${TAG}((?:\\s+\\w+="[^"]*")*)>\\n?([\\s\\S]*?)\\n?</${TAG}>`, "g");
@@ -15000,6 +15065,9 @@ function upsertDisplayMessage(messages, message2) {
   else messages[index] = message2;
   return message2;
 }
+function isToolInputQuestion(value) {
+  return isRecord(value) && typeof value.id === "string" && typeof value.prompt === "string" && typeof value.multiSelect === "boolean" && Array.isArray(value.options) && value.options.every((option) => isRecord(option) && typeof option.id === "string" && typeof option.label === "string");
+}
 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);
@@ -15099,6 +15167,16 @@ function planItemsFromMessage(message2) {
 function peerChatName(message2) {
   return message2.chat ?? "another chat";
 }
+function getDisplayMessageStatus(message2) {
+  if (message2.type === "error" || message2.type === "quota_status") return "failed";
+  if (message2.type === "auth_fallback") return message2.status === "switched" ? "completed" : "failed";
+  if (message2.type === "interruption" || message2.type === "multitask_event" || message2.type === "harness_switch") return "completed";
+  if (message2.type === "background_task") return message2.status === "stopped" ? "completed" : message2.status;
+  if (message2.type === "command" || message2.type === "patch") {
+    return message2.status ?? (message2.exitCode === void 0 ? "in_progress" : message2.exitCode === 0 ? "completed" : "failed");
+  }
+  return "status" in message2 ? message2.status : void 0;
+}
 function todoItemStatus(item) {
   return item.itemStatus ?? (item.completed ? "completed" : "pending");
 }
@@ -15135,6 +15213,17 @@ ${operation.diff}` : ""}`).join("\n\n");
   if (message2.type === "multitask_event") return { kind: "task", title: "Ship update", summary: message2.events.map((event) => `${event.agentName}: ${event.summary}`).join(" \xB7 "), content: "" };
   return { kind: "error", title: "Agent error", summary: "", content: message2.message };
 }
+function lineCountFromOutput(output) {
+  if (!output) return null;
+  let end = output.length;
+  while (end > 0 && output[end - 1] === "\n") end--;
+  if (end === 0) return null;
+  let lines = 1;
+  for (let i = 0; i < end; i++) {
+    if (output[i] === "\n") lines++;
+  }
+  return lines;
+}
 function fileContentDiff(path, content, action) {
   const lines = content.replace(/\n$/, "").split("\n");
   return [
@@ -15144,7 +15233,81 @@ function fileContentDiff(path, content, action) {
     ...lines.map((line) => `${action === "add" ? "+" : "-"}${line}`)
   ].join("\n");
 }
+function isRawFileContent(diff, action) {
+  const lines = diff.split("\n");
+  return !lines[0].startsWith("diff --git ") && !(lines[0].startsWith("--- ") && lines[1]?.startsWith("+++ ")) && !(action === "add" && lines.every((line) => line === "" || line.startsWith("+")));
+}
+function operationDiffStats({ diff, action }) {
+  if (!diff) return void 0;
+  if (action === "update" || !isRawFileContent(diff, action)) return getDiffStats(diff);
+  const lines = diff.replace(/\n$/, "").split("\n").length;
+  return action === "add" ? { added: lines, removed: 0 } : { added: 0, removed: lines };
+}
+function getDiffStats(diff) {
+  let added = 0;
+  let removed = 0;
+  let oldLeft = 0;
+  let newLeft = 0;
+  let lineStart = 0;
+  for (let i = 0; i <= diff.length; i++) {
+    if (i !== diff.length && diff[i] !== "\n") continue;
+    const first = diff[lineStart];
+    const hunk = first === "@" ? /^@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@/.exec(diff.slice(lineStart, i)) : null;
+    if (hunk) {
+      oldLeft = Number(hunk[1] ?? 1);
+      newLeft = Number(hunk[2] ?? 1);
+    } else if (oldLeft > 0 || newLeft > 0) {
+      if (first === "+") {
+        added++;
+        newLeft--;
+      } else if (first === "-") {
+        removed++;
+        oldLeft--;
+      } else if (first === " ") {
+        oldLeft--;
+        newLeft--;
+      }
+    } else if (!diff.startsWith("+++", lineStart) && !diff.startsWith("---", lineStart)) {
+      if (first === "+") added++;
+      else if (first === "-") removed++;
+    }
+    lineStart = i + 1;
+  }
+  return { added, removed };
+}
+var READ_COMMANDS = /* @__PURE__ */ new Set([
+  "cat",
+  "find",
+  "grep",
+  "head",
+  "ls",
+  "nl",
+  "pwd",
+  "rg",
+  "sed",
+  "tail",
+  "tree",
+  "wc"
+]);
 var SEARCH_COMMANDS = /* @__PURE__ */ new Set(["grep", "rg"]);
+var PIPE_FILTERS = /* @__PURE__ */ new Set(["awk", "cat", "column", "cut", "grep", "head", "jq", "nl", "rg", "sed", "sort", "tail", "tr", "uniq", "wc"]);
+var NEUTRAL_COMMANDS = /* @__PURE__ */ new Set(["cd", "echo", "printf", "true"]);
+var GIT_READ_COMMANDS = /* @__PURE__ */ new Set([
+  "branch",
+  "diff",
+  "grep",
+  "log",
+  "ls-files",
+  "show",
+  "status"
+]);
+var GH_READ_COMMANDS = /* @__PURE__ */ new Set([
+  "api",
+  "issue",
+  "pr",
+  "repo",
+  "run"
+]);
 var LINE_COUNT_VALUE_FLAGS = /* @__PURE__ */ new Set(["-c", "-n", "--bytes", "--lines"]);
 var SEARCH_VALUE_FLAGS = ["-A", "-B", "-C", "-d", "-e", "-f", "-m", "--after-context", "--before-context", "--context", "--file", "--max-count", "--regexp"];
 var VALUE_FLAGS = {
@@ -15160,9 +15323,26 @@ var PATTERN_FLAGS = /* @__PURE__ */ new Set(["-e", "-f", "--file", "--regexp"]);
 var SCRIPT_ROOT = "/
";
 var commandName = (argv) => argv[0].split("/").pop() ?? argv[0];
 var fileWrites = ({ writes }) => writes.filter(({ path }) => path !== "/dev/null");
+function displayPath(dir, path) {
+  if (path.startsWith("~")) return path;
+  const resolved = resolveShellPath(dir, path);
+  if (resolved === null) return null;
+  if (resolved === SCRIPT_ROOT) return ".";
+  if (resolved.startsWith(`${SCRIPT_ROOT}/`)) return resolved.slice(SCRIPT_ROOT.length + 1);
+  return path.startsWith("/") ? resolved : 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) {
   return Array.from(new Set(shellCommands(command).flatMap((shellCommand) => {
@@ -15228,10 +15408,72 @@ function readCommandPaths(command, words) {
   }
   return pathArgs(command, words.slice(1));
 }
+function readTitle(search, output, paths) {
+  const lines = lineCountFromOutput(output);
+  if (lines) return `Read ${lines} line${lines === 1 ? "" : "s"}${paths.length > 1 ? ` from ${paths.length} files` : ""}`;
+  return search ? "Search" : paths.length > 1 ? `Read ${paths.length} files` : "Read";
+}
+function writtenFile(command) {
+  const [write, ...rest] = shellCommands(command).filter(({ argv }) => !["cd", "mkdir"].includes(commandName(argv)));
+  if (!write || rest.length > 0 || write.piped || write.subshell || write.stdinFile !== null) return null;
+  if (!["cat", "echo", "printf"].includes(commandName(write.argv))) return null;
+  const writes = fileWrites(write);
+  return writes.length === 1 && writes[0].path ? displayPath(write.dir, writes[0].target) : null;
+}
 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));
 }
+function commandDisplayFromCommand(command, output) {
+  const written = writtenFile(command);
+  if (written) return { title: "Write", paths: [written] };
+  const commands = simpleCommands(command);
+  if (!commands || commands.some(({ name, argv, piped }) => writesFiles(name, argv) || piped && !PIPE_FILTERS.has(name))) return null;
+  const mainCommands = commands.filter(({ name, piped }) => !piped && !NEUTRAL_COMMANDS.has(name));
+  if (mainCommands.length === 0) return null;
+  if (mainCommands.length === 1) {
+    const [{ name, argv: words }] = mainCommands;
+    if (name === "git" && words[1] && GIT_READ_COMMANDS.has(words[1])) {
+      return { title: `Git ${words[1]}`, paths: [] };
+    }
+    if (name === "gh" && words[1] && GH_READ_COMMANDS.has(words[1])) {
+      return { title: words[1] === "pr" && words[2] ? `GitHub PR ${words[2]}` : "GitHub", paths: [] };
+    }
+  }
+  if (!mainCommands.every(({ name }) => READ_COMMANDS.has(name))) return null;
+  const paths = /* @__PURE__ */ new Set();
+  for (const { name, argv, dir } of mainCommands) {
+    for (const path of readCommandPaths(name, argv)) {
+      const shown = displayPath(dir, path);
+      if (shown === null) return null;
+      paths.add(shown);
+    }
+  }
+  const search = mainCommands.every(({ name }) => SEARCH_COMMANDS.has(name));
+  return { title: readTitle(search, output, [...paths]), paths: [...paths] };
+}
+
+// ../shared/src/display-message/tool-call.ts
+function parseToolCallInput(inputValue) {
+  const input = typeof inputValue === "string" ? inputValue : inputValue ? JSON.stringify(inputValue, null, 2) : "";
+  let inputObject = null;
+  if (inputValue && typeof inputValue !== "string") inputObject = inputValue;
+  else if (input)
+    try {
+      const parsed = JSON.parse(input);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+        inputObject = Object.fromEntries(Object.entries(parsed));
+    } catch {
+    }
+  const filePath = inputObject ? [inputObject.file_path, inputObject.filePath, inputObject.path, inputObject.filename, inputObject.file].find(
+    (value) => typeof value === "string" && value.trim().length > 0
+  ) : void 0;
+  return {
+    input,
+    inputObject,
+    filePath: filePath ?? input.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/m)?.[1]
+  };
+}
 
 // ../shared/src/display-message/parsers/mcp.ts
 function parseMcpToolName(name) {
@@ -15246,8 +15488,30 @@ function parseMcpToolName(name) {
   return { server, tool };
 }
 
+// ../shared/src/display-message/subagent-tools.ts
+function chatIdFrom(input) {
+  const value = parseToolCallInput(input).inputObject;
+  if (!value) return null;
+  if ("chatId" in value && typeof value.chatId === "string") return value.chatId;
+  return "chat_id" in value && typeof value.chat_id === "string" ? value.chat_id : null;
+}
+function subagentToolName(message2) {
+  const mcp = parseMcpToolName(message2.tool);
+  const server = mcp?.server ?? message2.server;
+  const tool = mcp?.tool ?? message2.tool;
+  return isSubagentMcpServerName(server) ? tool : null;
+}
+function subagentChatId(message2) {
+  const tool = subagentToolName(message2);
+  if (!tool || tool === SUBAGENT_MCP_TOOLS.getProviders || !isSubagentMcpToolName(tool)) return null;
+  const inputId = chatIdFrom(message2.input);
+  if (inputId) return inputId;
+  if (tool !== SUBAGENT_MCP_TOOLS.spawnAgent || !message2.output) return null;
+  return chatIdFrom(message2.output);
+}
+
 // ../shared/src/learned-skills.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // ../shared/src/frontmatter.ts
 import { parse as parseYaml } from "yaml";
@@ -15270,20 +15534,20 @@ function parseFrontmatter(content) {
 var LEARNED_SKILLS_ROOT = `${SANDBOX_PATHS.REPLICAS_DIR}/learned-skills`;
 var LEARNED_SKILLS_MANIFEST_PATH = `${LEARNED_SKILLS_ROOT}/manifest.json`;
 var LEARNED_SKILL_DIR_PREFIX = "replicas-learned__";
-var learnedSkillsManifestSchema = z21.object({
-  skills: z21.array(z21.object({ name: z21.string(), sha256: z21.string() }))
+var learnedSkillsManifestSchema = z22.object({
+  skills: z22.array(z22.object({ name: z22.string(), sha256: z22.string() }))
 });
-var dreamVerdictChecksSchema = z21.object({
-  repeatable: z21.boolean(),
-  realInstruction: z21.boolean(),
-  noContradiction: z21.boolean(),
-  formatExact: z21.boolean(),
-  humanOnly: z21.boolean(),
-  actionable: z21.boolean(),
-  durable: z21.boolean()
+var dreamVerdictChecksSchema = z22.object({
+  repeatable: z22.boolean(),
+  realInstruction: z22.boolean(),
+  noContradiction: z22.boolean(),
+  formatExact: z22.boolean(),
+  humanOnly: z22.boolean(),
+  actionable: z22.boolean(),
+  durable: z22.boolean()
 });
 var DREAM_VERDICT_CHECKS = dreamVerdictChecksSchema.keyof().options;
-var dreamVerdictSchema = dreamVerdictChecksSchema.extend({ approve: z21.boolean(), reason: z21.string() });
+var dreamVerdictSchema = dreamVerdictChecksSchema.extend({ approve: z22.boolean(), reason: z22.string() });
 var learnedSkillFormatInstruction = (speaker) => `Write a SKILL.md whose frontmatter has a kebab-case \`name\` and a short \`description\` that starts with "Use when" and names the situations it applies to; the body records only what ${speaker} actually said, restated as a direct instruction, usually one to three lines. Every line of a learning is loaded into future sessions, so leave out anything an agent could infer on its own: no headings, explanations, rules, or examples unless ${speaker} stated those specifics themselves. For "from now on, use Conventional Commits", the body is just "Use Conventional Commits for every commit message and PR title."`;
 
 // ../shared/src/user-message-matching.ts
@@ -15303,7 +15567,152 @@ function areUserMessagesWithinMatchWindow(a, b) {
   return a.content === b.content && Math.abs(parseTimestampMs(a.timestamp) - parseTimestampMs(b.timestamp)) <= USER_MESSAGE_MATCH_GRACE_PERIOD_MS;
 }
 
+// ../shared/src/display-message/turns.ts
+function isCompaction(message2) {
+  return message2.type === "reasoning" && message2.content === COMPACTION_CONTENT;
+}
+function isGoalUpdate(message2) {
+  return message2.type === "tool_call" && message2.server === "claude" && message2.tool === GOAL_TOOL_NAME;
+}
+
 // ../shared/src/display-message/steps.ts
+function inputString(input, ...keys) {
+  for (const key of keys) {
+    const value = input?.[key];
+    if (typeof value === "string" && value.trim()) return value;
+  }
+  return void 0;
+}
+var COMMAND_PARSE_LIMIT = 4096;
+function shellPayload(command) {
+  const [first] = parseShellScript(command, null);
+  const flag = first?.wrapper ? first.argv.findIndex((arg, index) => index > 0 && /^-[A-Za-z]*c[A-Za-z]*$/.test(arg)) : -1;
+  return (flag > 0 ? first.argv[flag + 1] : void 0)?.replaceAll(SHELL_OPAQUE, "\u2026") ?? command.trim();
+}
+function commandLabel(command) {
+  const lines = shellPayload(command.slice(0, COMMAND_PARSE_LIMIT)).replace(/^cd\s+\S+\s*&&\s*/, "").split("\n").filter((line) => line.trim());
+  const shown = lines.length > 1 && /(["']|<<-?\s*['"]?\w+['"]?)\s*$/.test(lines[0]) ? 2 : 1;
+  const label = lines.slice(0, shown).map((line) => line.trim()).join(" ");
+  return lines.length > shown ? `${label} \u2026` : label;
+}
+var BACKGROUND_META = {
+  in_progress: "Running in background",
+  completed: "Done in background",
+  failed: "Failed in background",
+  stopped: "Stopped in background"
+};
+var OPERATION_VERBS = {
+  add: ["Creating", "Created", "file-plus"],
+  delete: ["Deleting", "Deleted", "file-x"],
+  update: ["Editing", "Edited", "file-pen"]
+};
+function skillStep(base, key, skillName) {
+  return skillName.startsWith(LEARNED_SKILL_DIR_PREFIX) ? { ...base, key, category: "learning", icon: "lightbulb", live: "Using learning", done: "Used learning", target: { text: skillName.slice(LEARNED_SKILL_DIR_PREFIX.length) } } : { ...base, key, category: "skill", icon: "zap", live: "Using skill", done: "Used skill", target: { text: skillName } };
+}
+function describeMessageSteps(message2, durationMs, background) {
+  const status = getDisplayMessageStatus(message2);
+  const base = {
+    message: message2,
+    running: status === "in_progress",
+    failed: status === "failed",
+    durationMs
+  };
+  switch (message2.type) {
+    case "reasoning":
+      if (isCompaction(message2)) {
+        return [{ ...base, key: message2.id, category: "compact", icon: "fold", live: "Compacting context", done: base.failed ? "Context compaction" : "Compacted context" }];
+      }
+      if (!message2.content.trim()) return [];
+      return [{ ...base, key: message2.id, category: "think", icon: "brain", live: "Thinking", done: "Thought", failed: false, detail: "reasoning" }];
+    case "command": {
+      const policyBlocked = message2.status === "failed" && message2.exitCode == null && Boolean(message2.output?.toLowerCase().includes("blocked by organization policy"));
+      const display = policyBlocked || message2.command.length > COMMAND_PARSE_LIMIT ? null : commandDisplayFromCommand(message2.command);
+      const failed = policyBlocked || base.failed || message2.exitCode != null && message2.exitCode !== 0 || background?.status === "failed";
+      const running = background ? background.status === "in_progress" : base.running;
+      const meta = policyBlocked ? "Blocked by policy" : background ? BACKGROUND_META[background.status] : failed && message2.exitCode != null ? `Exit code ${message2.exitCode}` : void 0;
+      const shell = { ...base, meta, running, failed, detail: "shell", background };
+      const pathSkills = display?.paths.map(skillNameFromFilePath) ?? [];
+      if ((display?.title.startsWith("Read") || display?.title === "Search" && pathSkills.every(Boolean)) && display.paths.length > 0) {
+        return display.paths.map((path, index) => {
+          const key = index ? `${message2.id}-${index}` : message2.id;
+          const skillName = pathSkills[index];
+          return skillName ? skillStep(shell, key, skillName) : { ...shell, key, category: "read", icon: "book", live: "Reading", done: "Read", target: { text: path, path } };
+        });
+      }
+      if (display?.title === "Write") {
+        return [{ ...shell, key: message2.id, category: "edit", icon: "file-pen", live: "Writing", done: "Wrote", target: { text: display.paths[0], path: display.paths[0] } }];
+      }
+      return [...(message2.skillNames ?? []).map((skillName) => skillStep(shell, `${message2.id}-${skillName}`, skillName)), {
+        ...shell,
+        key: message2.id,
+        category: display?.title === "Search" ? "search" : "command",
+        icon: "terminal",
+        live: "Running",
+        done: "Ran",
+        target: { text: commandLabel(message2.command) }
+      }];
+    }
+    case "patch":
+      return message2.operations.map((operation, index) => {
+        const [live, done, icon] = OPERATION_VERBS[operation.action] ?? OPERATION_VERBS.update;
+        return {
+          ...base,
+          key: `${message2.id}-${index}`,
+          category: "edit",
+          icon,
+          live,
+          done,
+          target: { text: operation.moveTo ?? operation.path, path: operation.moveTo ?? operation.path },
+          detail: operation.diff ? "diff" : void 0,
+          operation
+        };
+      });
+    case "file_change":
+      return message2.changes.map((change, index) => {
+        const [live, done, icon] = OPERATION_VERBS[change.kind] ?? OPERATION_VERBS.update;
+        return { ...base, key: `${message2.id}-${index}`, category: "edit", icon, live, done, target: { text: change.path, path: change.path } };
+      });
+    case "web_search":
+      return [{ ...base, key: message2.id, category: "web", icon: "globe", live: "Searching the web for", done: "Searched the web for", target: { text: message2.query } }];
+    case "skill":
+      return [skillStep(base, message2.id, message2.skillName)];
+    case "subagent":
+      return [{
+        ...base,
+        // A foreground agent's spawning call returns only when it finishes, so its result settles the step even when the
+        // task's own completion was never recorded. A backgrounded agent's call returns at launch.
+        ...background?.isBackgrounded && { running: background.status === "in_progress", failed: background.status === "failed" },
+        key: message2.id,
+        category: "agent",
+        icon: "bot",
+        live: "Running",
+        done: "Ran",
+        target: { text: message2.description, plain: true },
+        background
+      }];
+    case "background_task":
+      if (message2.toolUseId) return [];
+      return [{ ...base, key: message2.id, category: "task", icon: "bell", live: "Running", done: "Ran", target: { text: message2.description ?? message2.summary ?? "background task", plain: true } }];
+    case "peer_message":
+      return [message2.direction === "received" ? { ...base, key: message2.id, category: "message", icon: "message", live: "Message from", done: "Message from", target: { text: peerChatName(message2), plain: true }, detail: "peer" } : { ...base, key: message2.id, category: "message", icon: "send", live: "Messaging", done: "Messaged", target: { text: peerChatName(message2), plain: true }, detail: "peer" }];
+    case "tool_call": {
+      const step = describeToolCall(message2, base);
+      return step ? [step] : [];
+    }
+    case "capacity_retry":
+      return [{
+        ...base,
+        key: message2.id,
+        category: "retry",
+        icon: "clock",
+        live: "Retrying",
+        done: "Retried",
+        target: { text: `(model at capacity, ${message2.attempt} of ${message2.maxAttempts})`, plain: true }
+      }];
+    default:
+      return [];
+  }
+}
 var SUBAGENT_STEPS = {
   [SUBAGENT_MCP_TOOLS.messageAgent]: { icon: "message", live: "Messaging", done: "Messaged" },
   [SUBAGENT_MCP_TOOLS.waitAgent]: { icon: "clock", live: "Waiting for", done: "Waited for" },
@@ -15340,6 +15749,130 @@ var REPLICAS_API_STEPS = {
   [REPLICAS_MCP_TOOLS.listEnvironments]: { icon: "list", live: "Listing environments", done: "Listed environments" },
   [REPLICAS_MCP_TOOLS.createAutomation]: { icon: "clock", live: "Creating automation", done: "Created automation" }
 };
+var INTERNAL_TOOLS = /* @__PURE__ */ new Set(["ToolSearch", "ListAgents", "ListMcpResourcesTool", "ReadMcpResourceTool", "TaskOutput", "BashOutput"]);
+function describeToolCall(message2, base) {
+  const { inputObject: input, filePath } = parseToolCallInput(message2.input);
+  const tool = message2.tool;
+  const key = message2.id;
+  if (INTERNAL_TOOLS.has(tool)) return null;
+  if (isGoalUpdate(message2)) {
+    const objective = inputString(input, "objective");
+    return objective ? { ...base, key, category: "tool", icon: "target", live: "Setting goal", done: "Set goal", target: { text: objective, plain: true } } : { ...base, key, category: "tool", icon: "target", live: "Clearing goal", done: "Cleared goal" };
+  }
+  const subagentTool = subagentToolName(message2);
+  if (subagentTool && isSubagentMcpToolName(subagentTool)) {
+    const failed = base.failed || typeof parseToolCallInput(message2.output).inputObject?.error === "string";
+    if (subagentTool === SUBAGENT_MCP_TOOLS.spawnAgent) {
+      return { ...base, key, category: "agent", icon: "bot", live: "Running", done: "Started", failed, target: { text: inputString(input, "title", "prompt") ?? "subagent", plain: true } };
+    }
+    const chatId = subagentChatId(message2);
+    const provider2 = typeof input?.provider === "string" && isValidAgentProvider(input.provider) ? input.provider : null;
+    const agent = inputString(input, "title") ?? chatId?.slice(0, 8) ?? (provider2 ? getProviderDisplayName(provider2) : void 0);
+    return { ...base, key, category: "tool", ...SUBAGENT_STEPS[subagentTool], failed, target: agent ? { text: agent, plain: true } : void 0, detail: "subagent" };
+  }
+  const mcp = parseMcpToolName(tool);
+  const replicasTool = (mcp?.server ?? message2.server) === REPLICAS_MCP_SERVER_NAME ? mcp?.tool ?? tool : tool.startsWith(`${REPLICAS_MCP_SERVER_NAME}_`) ? tool.slice(REPLICAS_MCP_SERVER_NAME.length + 1) : void 0;
+  const mothershipAction = replicasTool ? MOTHERSHIP_TOOL_ACTIONS[replicasTool] : void 0;
+  if (mothershipAction) {
+    const step = {
+      ...base,
+      key,
+      failed: base.failed || Boolean(message2.output?.startsWith("Error:")),
+      mothership: { action: mothershipAction, name: inputString(input, "name"), agentId: inputString(input, "agent_id"), chatId: inputString(input, "chat_id"), text: inputString(input, "prompt", "message") }
+    };
+    if (mothershipAction === "spawn") return { ...step, category: "agent", icon: "network", live: "Spawning", done: "Spawned", detail: "mothership" };
+    if (mothershipAction === "send") return { ...step, category: "agent", icon: "message", live: "Messaging", done: "Messaged", detail: "mothership" };
+    if (mothershipAction === "wait") {
+      return { ...step, category: "agent", icon: "clock", live: "Waiting for ships", done: "Waited for ships", detail: "mothership", mothership: { ...step.mothership, events: extractMothershipEvents(message2.output ?? "") } };
+    }
+    if (mothershipAction === "archive") return { ...step, category: "tool", icon: "archive", live: "Archiving ship", done: "Archived ship", detail: "io" };
+    return mothershipAction === "list" ? { ...step, category: "tool", icon: "network", live: "Listing ships", done: "Listed ships", detail: "io" } : { ...step, category: "tool", icon: "network", live: "Reading ship response", done: "Read ship response", detail: "io" };
+  }
+  const replicasStep = replicasTool ? REPLICAS_API_STEPS[replicasTool] : void 0;
+  if (replicasStep) {
+    const replica = parseToolCallInput(message2.output).inputObject?.replica;
+    const replicaFields = isRecord(replica) ? replica : null;
+    const command = replicasTool === REPLICAS_MCP_TOOLS.runCommand ? inputString(input, "command") : void 0;
+    const name = inputString(input, "name") ?? inputString(replicaFields, "name");
+    const workspaceId = inputString(input, "id") ?? inputString(replicaFields, "id");
+    const label = command ? commandLabel(command) : inputString(input, "title") ?? (replicasTool === REPLICAS_MCP_TOOLS.createAutomation ? name : void 0);
+    return {
+      ...base,
+      key,
+      category: "tool",
+      ...replicasStep,
+      target: label ? { text: label, plain: !command } : void 0,
+      workspace: workspaceId && UUID_RE.test(workspaceId) ? { id: workspaceId, name } : void 0,
+      detail: message2.input || message2.output ? "io" : void 0
+    };
+  }
+  const shellCommand = /^(bash|shell|run_shell_command)$/i.test(tool) ? inputString(input, "command", "cmd") : void 0;
+  if (shellCommand) {
+    return { ...base, key, category: "command", icon: "terminal", live: "Running", done: "Ran", target: { text: commandLabel(shellCommand) }, detail: "io" };
+  }
+  if (/^(read|read_file|view)$/i.test(tool) && filePath) {
+    return { ...base, key, category: "read", icon: "book", live: "Reading", done: "Read", target: { text: filePath, path: filePath }, detail: "io" };
+  }
+  if (/^(grep|glob|search|find|codebase_search|file_search)$/i.test(tool)) {
+    const scope = inputString(input, "path", "glob", "include", "target_directories");
+    return {
+      ...base,
+      key,
+      category: "search",
+      icon: "search",
+      live: "Searching for",
+      done: "Searched for",
+      target: { text: inputString(input, "pattern", "query", "glob_pattern", "globPattern") ?? tool },
+      scope,
+      detail: message2.output ? "results" : void 0
+    };
+  }
+  if (/^(ls|list_dir|list_directory)$/i.test(tool)) {
+    const path = inputString(input, "path", "relative_workspace_path") ?? ".";
+    return { ...base, key, category: "read", icon: "folder", live: "Listing", done: "Listed", target: { text: path, path }, detail: "io" };
+  }
+  if (/^(webfetch|web_fetch|fetch)$/i.test(tool)) {
+    return { ...base, key, category: "web", icon: "globe", live: "Fetching", done: "Fetched", target: { text: inputString(input, "url") ?? tool }, detail: "io" };
+  }
+  if (/^(websearch|web_search)$/i.test(tool)) {
+    return { ...base, key, category: "web", icon: "globe", live: "Searching the web for", done: "Searched the web for", target: { text: inputString(input, "query") ?? tool } };
+  }
+  if (/^(edit|write|multiedit|notebookedit|apply_patch|str_replace)/i.test(tool) && filePath) {
+    return { ...base, key, category: "edit", icon: "file-pen", live: "Editing", done: "Edited", target: { text: filePath, path: filePath }, detail: "io" };
+  }
+  return {
+    ...base,
+    key,
+    category: "tool",
+    icon: "wrench",
+    live: "Calling",
+    done: "Called",
+    target: { text: mcp?.tool ?? tool },
+    scope: mcp?.server ?? (message2.server && message2.server !== "claude" ? message2.server : void 0),
+    detail: message2.input || message2.output ? "io" : void 0
+  };
+}
+var stepCache = /* @__PURE__ */ new WeakMap();
+function describeSteps(message2, { durations, backgroundTasks }) {
+  const durationMs = durations.get(message2.id);
+  const backgroundId = message2.type === "command" ? /^Command running in background with ID: (\w+)/.exec(message2.output ?? "")?.[1] : message2.type === "subagent" ? message2.toolUseId : void 0;
+  const background = backgroundId ? backgroundTasks?.get(backgroundId) : void 0;
+  const cached = stepCache.get(message2);
+  if (cached && cached.durationMs === durationMs && cached.background === background) return cached.steps;
+  const steps = describeMessageSteps(message2, durationMs, background).map((step) => ({
+    ...step,
+    stats: step.operation && !step.failed ? operationDiffStats(step.operation) : void 0
+  }));
+  stepCache.set(message2, { durationMs, background, steps });
+  return steps;
+}
+var NO_DURATIONS = /* @__PURE__ */ new Map();
+function currentStepLabel(messages) {
+  const step = messages.flatMap((message2) => describeSteps(message2, { durations: NO_DURATIONS })).filter((candidate) => candidate.running).at(-1);
+  if (!step) return void 0;
+  const target = step.target?.path ? step.target.path.split("/").pop() : step.target?.text;
+  return [step.live, target].filter(Boolean).join(" ");
+}
 
 // ../shared/src/user-message-attachments.ts
 var ATTACHMENT_PLACEHOLDER_REGEX = /^\[\d+ (?:(?:images?|files?)(?: and \d+ files?)? attached|(?:image )?attachments?)\]$/;
@@ -16386,9 +16919,6 @@ function parseOpencodeEvents(events) {
 }
 
 // ../shared/src/display-message/parsers/muse-parser.ts
-function isToolInputQuestion(value) {
-  return isRecord(value) && typeof value.id === "string" && typeof value.prompt === "string" && typeof value.multiSelect === "boolean" && Array.isArray(value.options) && value.options.every((option) => isRecord(option) && typeof option.id === "string" && typeof option.label === "string");
-}
 function parseMuseEvents(events) {
   const messages = [];
   const deltas = /* @__PURE__ */ new Map();
@@ -18762,7 +19292,7 @@ var CLAUDE_AUTH_ENV_KEYS_BY_METHOD = {
 };
 
 // ../shared/src/routes/command-protection.ts
-import { z as z22 } from "zod";
+import { z as z23 } 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"]);
@@ -18853,27 +19383,27 @@ function findCheckoutTarget(args) {
 }
 
 // ../shared/src/routes/command-protection.ts
-var commandProtectionRepoStateSchema = z22.object({
-  branch: z22.string().nullable(),
-  defaultBranch: z22.string().nullable(),
-  pushBranch: z22.string().nullable(),
-  pushConfig: z22.string().nullable(),
-  headMessage: z22.string().nullable(),
-  mergeInProgress: z22.boolean().optional()
+var commandProtectionRepoStateSchema = z23.object({
+  branch: z23.string().nullable(),
+  defaultBranch: z23.string().nullable(),
+  pushBranch: z23.string().nullable(),
+  pushConfig: z23.string().nullable(),
+  headMessage: z23.string().nullable(),
+  mergeInProgress: z23.boolean().optional()
 });
-var commandProtectionEvaluateRequestSchema = z22.object({
-  provider: z22.enum(["claude", "codex", "cursor", "opencode", "pi"]),
-  source: z22.enum(["claude_pre_tool_use", "codex_approval_request", "cursor_pre_tool_use", "opencode_pre_tool_use", "pi_tool_call"]),
-  toolName: z22.string(),
-  toolInput: z22.unknown(),
-  command: z22.string().nullish(),
-  cwd: z22.string().nullish(),
-  toolUseId: z22.string().nullish(),
+var commandProtectionEvaluateRequestSchema = z23.object({
+  provider: z23.enum(["claude", "codex", "cursor", "opencode", "pi"]),
+  source: z23.enum(["claude_pre_tool_use", "codex_approval_request", "cursor_pre_tool_use", "opencode_pre_tool_use", "pi_tool_call"]),
+  toolName: z23.string(),
+  toolInput: z23.unknown(),
+  command: z23.string().nullish(),
+  cwd: z23.string().nullish(),
+  toolUseId: z23.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: z22.object({
-    repos: z22.record(z22.string(), commandProtectionRepoStateSchema),
-    messageFiles: z22.record(z22.string(), z22.string())
+  gitContext: z23.object({
+    repos: z23.record(z23.string(), commandProtectionRepoStateSchema),
+    messageFiles: z23.record(z23.string(), z23.string())
   }).optional()
 });
 var COMMAND_PROTECTION_COMMAND_KEYS = ["command", "cmd", "script", "query", "endpoint", "path", "url", "mutation"];
@@ -19093,118 +19623,118 @@ function shouldRefreshPullRequests(toolName, toolInput) {
 }
 
 // ../shared/src/routes/linear.ts
-import { z as z23 } from "zod";
-var linearSessionMetadataSchema = z23.object({
-  via_mothership: z23.boolean().optional(),
-  attached: z23.boolean().optional(),
-  issue_id: z23.string(),
-  issue_identifier: z23.string(),
-  issue_title: z23.string(),
-  issue_description: z23.string(),
-  issue_url: z23.string(),
-  comment_id: z23.string(),
-  comment_body: z23.string(),
-  triggered_by_id: z23.string().optional(),
-  triggered_by_name: z23.string().optional(),
-  triggered_by_email: z23.string().optional(),
-  linear_workspace_id: z23.string().optional(),
-  creator_id: z23.string().optional(),
-  creator_name: z23.string().optional(),
-  creator_email: z23.string().optional(),
-  assignee_id: z23.string().optional(),
-  assignee_name: z23.string().optional(),
-  assignee_email: z23.string().optional(),
-  issue_state: z23.string().optional(),
-  parent_issue: z23.object({
-    id: z23.string(),
-    identifier: z23.string(),
-    title: z23.string(),
-    description: z23.string().nullable()
+import { z as z24 } from "zod";
+var linearSessionMetadataSchema = z24.object({
+  via_mothership: z24.boolean().optional(),
+  attached: z24.boolean().optional(),
+  issue_id: z24.string(),
+  issue_identifier: z24.string(),
+  issue_title: z24.string(),
+  issue_description: z24.string(),
+  issue_url: z24.string(),
+  comment_id: z24.string(),
+  comment_body: z24.string(),
+  triggered_by_id: z24.string().optional(),
+  triggered_by_name: z24.string().optional(),
+  triggered_by_email: z24.string().optional(),
+  linear_workspace_id: z24.string().optional(),
+  creator_id: z24.string().optional(),
+  creator_name: z24.string().optional(),
+  creator_email: z24.string().optional(),
+  assignee_id: z24.string().optional(),
+  assignee_name: z24.string().optional(),
+  assignee_email: z24.string().optional(),
+  issue_state: z24.string().optional(),
+  parent_issue: z24.object({
+    id: z24.string(),
+    identifier: z24.string(),
+    title: z24.string(),
+    description: z24.string().nullable()
   }).optional(),
-  workspace: z23.object({
-    id: z23.string(),
-    coding_agent: z23.custom((value) => typeof value === "string" && isValidAgentProvider(value)),
-    task_description: z23.string(),
-    created_at: z23.string()
+  workspace: z24.object({
+    id: z24.string(),
+    coding_agent: z24.custom((value) => typeof value === "string" && isValidAgentProvider(value)),
+    task_description: z24.string(),
+    created_at: z24.string()
   }).optional()
 });
 
 // ../shared/src/routes/scout.ts
-import { z as z24 } from "zod";
+import { z as z25 } from "zod";
 var SCOUT_LINEAR_ACTIONS = ["ask", "start"];
-var scoutLinearSessionIntentRequestSchema = z24.object({
-  comment_id: z24.string().trim().min(1).describe("Id of the Linear comment the session will be created on."),
-  action: z24.enum(SCOUT_LINEAR_ACTIONS).describe("`ask` when the comment is a clarifying question, `start` when it hands off the task.")
+var scoutLinearSessionIntentRequestSchema = z25.object({
+  comment_id: z25.string().trim().min(1).describe("Id of the Linear comment the session will be created on."),
+  action: z25.enum(SCOUT_LINEAR_ACTIONS).describe("`ask` when the comment is a clarifying question, `start` when it hands off the task.")
 });
-var scoutLinearStartRequestSchema = z24.object({
-  issue_id: z24.string().describe("Linear issue id from the envelope's `issue_id`."),
-  agent_session_id: z24.string().describe("Existing Linear agent session id from the envelope's `agent_session_id`."),
-  prompt: z24.string().trim().min(1).describe("The latest request, in its author's words. The workspace already receives the issue and its comments.")
+var scoutLinearStartRequestSchema = z25.object({
+  issue_id: z25.string().describe("Linear issue id from the envelope's `issue_id`."),
+  agent_session_id: z25.string().describe("Existing Linear agent session id from the envelope's `agent_session_id`."),
+  prompt: z25.string().trim().min(1).describe("The latest request, in its author's words. The workspace already receives the issue and its comments.")
 });
-var slackChannelIdSchema = z24.string().describe("Slack channel id from the envelope's `channel_id`.");
-var slackThreadTsSchema = z24.string().describe("Slack thread timestamp from the envelope's `thread_ts`.");
-var scoutSlackSpawnRequestSchema = z24.object({
+var slackChannelIdSchema = z25.string().describe("Slack channel id from the envelope's `channel_id`.");
+var slackThreadTsSchema = z25.string().describe("Slack thread timestamp from the envelope's `thread_ts`.");
+var scoutSlackSpawnRequestSchema = z25.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message_ts: z24.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: z24.string().describe("Slack user id of that message's author (the envelope's `user_id`). The workspace is attributed to them."),
-  prompt: z24.string().describe("The person's request in their own words, quoting earlier messages only when it points to them. The workspace already receives the Slack thread, so add no research, plan, or guesses."),
-  acknowledgement_ts: z24.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the workspace link to it and tells the workspace not to acknowledge again."),
-  environment_id: z24.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: z25.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: z25.string().describe("Slack user id of that message's author (the envelope's `user_id`). The workspace is attributed to them."),
+  prompt: z25.string().describe("The person's request in their own words, quoting earlier messages only when it points to them. The workspace already receives the Slack thread, so add no research, plan, or guesses."),
+  acknowledgement_ts: z25.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the workspace link to it and tells the workspace not to acknowledge again."),
+  environment_id: z25.string().optional().describe(`Environment id from \`${REPLICAS_MCP_TOOLS.listEnvironments}\`. Pass it only when clearly confident it fits; omit it to let routing choose. If routing cannot choose, the call fails and nothing is posted, so pick one or ask the person.`)
 });
 var scoutSlackSpawnInNewThreadRequestSchema = scoutSlackSpawnRequestSchema.extend({
-  title: z24.string().trim().min(1).max(500).describe("One or two sentences stating the task, posted as the new top-level message."),
-  prompt: z24.string().describe("The person's request in their own words. The full source thread is attached as background, so add no summary, research, plan, or guesses."),
-  acknowledgement_ts: z24.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the new thread's link to it.")
+  title: z25.string().trim().min(1).max(500).describe("One or two sentences stating the task, posted as the new top-level message."),
+  prompt: z25.string().describe("The person's request in their own words. The full source thread is attached as background, so add no summary, research, plan, or guesses."),
+  acknowledgement_ts: z25.string().optional().describe("`ts` of the one-line reply you posted in this thread before spawning. The server appends the new thread's link to it.")
 });
-var scoutSlackRelayRequestSchema = z24.object({
+var scoutSlackRelayRequestSchema = z25.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message: z24.string().describe("The follow-up to deliver: every fresh message that belongs to this update, in its author's words, with no research, plan, or guesses added."),
-  user_id: z24.string().optional().describe("Slack user id of the follow-up's author (the envelope's `user_id`), so it is attributed to them. Defaults to the thread's original requester. Required with `workspace_id`."),
-  queue: z24.boolean().optional().describe("Set true only when the person explicitly asked for this to happen after the current task finishes. Delivers behind the active turn instead of interrupting it."),
-  workspace_id: z24.string().optional().describe(`Existing workspace id, from \`${REPLICAS_MCP_TOOLS.listWorkspaces}\` or a workspace link in the thread, to bind a thread without a workspace to before relaying. The author must be able to see it. A Mothership gets the person's own Slack message and the thread instead of \`message\`. Omit to relay into the thread's own workspace.`),
-  message_ts: z24.string().optional().describe("Timestamp of the Slack message that led to this relay (the envelope's `message_ts`). Required with `workspace_id`; the server verifies this message and its author.")
+  message: z25.string().describe("The follow-up to deliver: every fresh message that belongs to this update, in its author's words, with no research, plan, or guesses added."),
+  user_id: z25.string().optional().describe("Slack user id of the follow-up's author (the envelope's `user_id`), so it is attributed to them. Defaults to the thread's original requester. Required with `workspace_id`."),
+  queue: z25.boolean().optional().describe("Set true only when the person explicitly asked for this to happen after the current task finishes. Delivers behind the active turn instead of interrupting it."),
+  workspace_id: z25.string().optional().describe(`Existing workspace id, from \`${REPLICAS_MCP_TOOLS.listWorkspaces}\` or a workspace link in the thread, to bind a thread without a workspace to before relaying. The author must be able to see it. A Mothership gets the person's own Slack message and the thread instead of \`message\`. Omit to relay into the thread's own workspace.`),
+  message_ts: z25.string().optional().describe("Timestamp of the Slack message that led to this relay (the envelope's `message_ts`). Required with `workspace_id`; the server verifies this message and its author.")
 });
-var scoutSlackSetThreadMutedRequestSchema = z24.object({
+var scoutSlackSetThreadMutedRequestSchema = z25.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  muted: z24.boolean().describe("true to mute Replicas in this thread, false to unmute it.")
+  muted: z25.boolean().describe("true to mute Replicas in this thread, false to unmute it.")
 });
-var scoutListWorkspacesRequestSchema = z24.object({
+var scoutListWorkspacesRequestSchema = z25.object({
   channel_id: slackChannelIdSchema,
   thread_ts: slackThreadTsSchema,
-  message_ts: z24.string().describe("The envelope's `message_ts`. The server verifies this message and its author."),
-  user_id: z24.string().describe("Slack user id of that message's author (the envelope's `user_id`). Only workspaces they can see are listed."),
-  query: z24.string().trim().min(1).optional().describe("Case-insensitive text to match against workspace and Mothership names and pull request URLs.")
+  message_ts: z25.string().describe("The envelope's `message_ts`. The server verifies this message and its author."),
+  user_id: z25.string().describe("Slack user id of that message's author (the envelope's `user_id`). Only workspaces they can see are listed."),
+  query: z25.string().trim().min(1).optional().describe("Case-insensitive text to match against workspace and Mothership names and pull request URLs.")
 });
-var scoutSlackConfirmationSchema = z24.object({
-  confirmation_channel_id: z24.string().describe("`channel_id` from the envelope of the Slack message that asked for or accepted this."),
-  confirmation_thread_ts: z24.string().describe("`thread_ts` from that message's envelope."),
-  confirmation_message_ts: z24.string().describe("`message_ts` from that message's envelope."),
-  confirmation_user_id: z24.string().describe("`user_id` from that message's envelope.")
+var scoutSlackConfirmationSchema = z25.object({
+  confirmation_channel_id: z25.string().describe("`channel_id` from the envelope of the Slack message that asked for or accepted this."),
+  confirmation_thread_ts: z25.string().describe("`thread_ts` from that message's envelope."),
+  confirmation_message_ts: z25.string().describe("`message_ts` from that message's envelope."),
+  confirmation_user_id: z25.string().describe("`user_id` from that message's envelope.")
 });
 var scoutAutomationToolInputSchema = automationToolInputSchema.extend(scoutSlackConfirmationSchema.shape);
 var scoutSaveChannelPresetToolInputSchema = scoutSlackConfirmationSchema.extend({
-  preset_id: z24.string().optional().describe(`Id of the preset to update, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`. Omit to create a new preset.`),
-  name: z24.string().trim().min(1).max(SCOUT_PRESET_NAME_MAX_LENGTH).optional().describe("Preset name. Required when creating."),
-  description: z24.string().optional().describe("One-line summary shown in settings."),
-  icon: z24.enum(SCOUT_PRESET_ICONS).optional(),
-  instructions: z24.string().optional().describe("Complete preset instructions; replaces the existing text. Required when creating.")
+  preset_id: z25.string().optional().describe(`Id of the preset to update, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`. Omit to create a new preset.`),
+  name: z25.string().trim().min(1).max(SCOUT_PRESET_NAME_MAX_LENGTH).optional().describe("Preset name. Required when creating."),
+  description: z25.string().optional().describe("One-line summary shown in settings."),
+  icon: z25.enum(SCOUT_PRESET_ICONS).optional(),
+  instructions: z25.string().optional().describe("Complete preset instructions; replaces the existing text. Required when creating.")
 });
 var scoutUpdateChannelSettingsToolInputSchema = scoutSlackConfirmationSchema.extend({
-  source: z24.enum(SCOUT_SOURCE_TYPES).optional().describe("Defaults to `slack`."),
-  external_id: z24.string().describe("Slack channel id or Linear team id."),
-  monitored: z24.boolean().optional().describe("Linear: `true` starts monitoring the team (organization admins only), `false` stops. Slack: kept for older callers; prefer `proactivity`. `false` means `tagged`, and `true` lifts a `tagged` channel back to the organization's level. Omit to keep it."),
-  preset_id: z24.string().nullable().optional().describe("Preset to assign; `null` removes the preset. Omit to keep it."),
-  instructions: z24.string().nullable().optional().describe("Complete channel-specific instructions, applied after the preset; replaces the existing text. `null` clears them. Omit to keep them."),
-  proactivity: z24.enum([...SCOUT_PROACTIVITY_LEVELS, "organization"]).optional().describe("Slack only: this channel's or group DM's own level, overriding the organization's here alone. `organization` makes it follow the organization's level again. Omit to keep it. 1:1 DMs are always addressed to Replicas, so they take no level.")
+  source: z25.enum(SCOUT_SOURCE_TYPES).optional().describe("Defaults to `slack`."),
+  external_id: z25.string().describe("Slack channel id or Linear team id."),
+  monitored: z25.boolean().optional().describe("Linear: `true` starts monitoring the team (organization admins only), `false` stops. Slack: kept for older callers; prefer `proactivity`. `false` means `tagged`, and `true` lifts a `tagged` channel back to the organization's level. Omit to keep it."),
+  preset_id: z25.string().nullable().optional().describe("Preset to assign; `null` removes the preset. Omit to keep it."),
+  instructions: z25.string().nullable().optional().describe("Complete channel-specific instructions, applied after the preset; replaces the existing text. `null` clears them. Omit to keep them."),
+  proactivity: z25.enum([...SCOUT_PROACTIVITY_LEVELS, "organization"]).optional().describe("Slack only: this channel's or group DM's own level, overriding the organization's here alone. `organization` makes it follow the organization's level again. Omit to keep it. 1:1 DMs are always addressed to Replicas, so they take no level.")
 });
 var scoutSetOrganizationProactivityToolInputSchema = scoutSlackConfirmationSchema.extend({
-  proactivity: z24.enum(SCOUT_PROACTIVITY_LEVELS).describe("The level every Slack channel and group DM follows unless it has its own. Slack Connect channels without their own level stay `tagged`.")
+  proactivity: z25.enum(SCOUT_PROACTIVITY_LEVELS).describe("The level every Slack channel and group DM follows unless it has its own. Slack Connect channels without their own level stay `tagged`.")
 });
 var scoutDeleteChannelPresetToolInputSchema = scoutSlackConfirmationSchema.extend({
-  preset_id: z24.string().describe(`Id of the preset to delete, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`.`)
+  preset_id: z25.string().describe(`Id of the preset to delete, from \`${REPLICAS_MCP_TOOLS.listChannelSettings}\`.`)
 });
 
 // ../shared/src/routes/plugin-catalog.ts
@@ -19585,85 +20115,81 @@ var promptHistoryClientStateKey = orgUserClientStateKey(PROMPT_HISTORY_CLIENT_ST
 var workspaceSearchOpensClientStateKey = orgUserClientStateKey(WORKSPACE_SEARCH_OPENS_CLIENT_STATE_KEY_PREFIX);
 
 // ../shared/src/routes/workspace-events.ts
-import { z as z25 } from "zod";
-
-// ../shared/src/workspace-attention.ts
-var WORKSPACE_ATTENTION_REASONS = ["question", "blocked"];
-
-// ../shared/src/routes/workspace-events.ts
-var workspaceTurnCompletionSchema = z25.object({
-  workspaceName: z25.string(),
-  completedAt: z25.string(),
-  processing: z25.boolean().optional(),
-  pullRequestFeedback: z25.boolean().optional(),
-  attention: z25.object({ reason: z25.enum(WORKSPACE_ATTENTION_REASONS), userId: z25.string() }).optional()
+import { z as z26 } from "zod";
+var workspaceTurnCompletionSchema = z26.object({
+  workspaceName: z26.string(),
+  completedAt: z26.string(),
+  processing: z26.boolean().optional(),
+  pullRequestFeedback: z26.boolean().optional(),
+  attention: z26.object({ reason: z26.enum(CHAT_ATTENTION_REASONS), userId: z26.string() }).optional()
 });
-var workspaceChangedEventSchema = z25.discriminatedUnion("type", [
-  z25.object({
-    type: z25.literal("workspace.changed"),
-    workspaceId: z25.string(),
-    workspace: z25.object({ status: z25.enum(WORKSPACE_STATUSES), last_activity_at: z25.string().nullable() }).optional(),
+var workspaceChangedEventSchema = z26.discriminatedUnion("type", [
+  z26.object({
+    type: z26.literal("workspace.changed"),
+    workspaceId: z26.string(),
+    workspace: z26.object({ status: z26.enum(WORKSPACE_STATUSES), last_activity_at: z26.string().nullable() }).optional(),
     completion: workspaceTurnCompletionSchema.optional(),
-    ts: z25.string()
+    ts: z26.string()
   }),
-  z25.object({
-    type: z25.literal("workspace.chat.changed"),
-    workspaceId: z25.string(),
-    chatId: z25.string(),
-    ts: z25.string()
+  z26.object({
+    type: z26.literal("workspace.chat.changed"),
+    workspaceId: z26.string(),
+    chatId: z26.string(),
+    ts: z26.string()
   }),
-  z25.object({
-    type: z25.literal("workspace.chat.advanced"),
-    workspaceId: z25.string(),
-    chatId: z25.string(),
-    afterCursor: z25.string().optional(),
-    processing: z25.boolean(),
-    ts: z25.string()
+  z26.object({
+    type: z26.literal("workspace.chat.advanced"),
+    workspaceId: z26.string(),
+    chatId: z26.string(),
+    afterCursor: z26.string().optional(),
+    processing: z26.boolean(),
+    ts: z26.string()
   }),
-  z25.object({ type: z25.literal("presence.changed"), ts: z25.string() }),
-  z25.object({
-    type: z25.literal("mobile-testing.changed"),
-    workspaceId: z25.string(),
-    ts: z25.string()
+  z26.object({ type: z26.literal("presence.changed"), ts: z26.string() }),
+  z26.object({
+    type: z26.literal("mobile-testing.changed"),
+    workspaceId: z26.string(),
+    ts: z26.string()
   }),
-  z25.object({
-    type: z25.literal("variable-request.changed"),
-    workspaceId: z25.string(),
-    ts: z25.string()
+  z26.object({
+    type: z26.literal("variable-request.changed"),
+    workspaceId: z26.string(),
+    ts: z26.string()
   }),
-  z25.object({
-    type: z25.literal("pull-request.changed"),
-    prUrl: z25.string(),
-    ts: z25.string()
+  z26.object({
+    type: z26.literal("pull-request.changed"),
+    prUrl: z26.string(),
+    ts: z26.string()
   }),
-  z25.object({
-    type: z25.literal("mothership.subagent.changed"),
-    workspaceId: z25.string(),
-    subagent: z25.object({ id: z25.string(), name: z25.string(), prUrl: z25.string().nullable() }),
-    ts: z25.string()
-  })
+  z26.object({
+    type: z26.literal("mothership.subagent.changed"),
+    workspaceId: z26.string(),
+    subagent: z26.object({ id: z26.string(), name: z26.string(), prUrl: z26.string().nullable() }),
+    ts: z26.string()
+  }),
+  z26.object({ type: z26.literal("needs-you.changed"), workspaceId: z26.string().nullable(), ts: z26.string() })
 ]);
 
 // ../shared/src/routes/presence.ts
-import { z as z26 } from "zod";
-var presenceStatusSchema = z26.enum(["online", "typing"]);
-var presenceLocationSchema = z26.object({
-  workspaceId: z26.string().optional()
+import { z as z27 } from "zod";
+var presenceStatusSchema = z27.enum(["online", "typing"]);
+var presenceLocationSchema = z27.object({
+  workspaceId: z27.string().optional()
 });
-var presenceEntrySchema = z26.object({
-  userId: z26.string(),
+var presenceEntrySchema = z27.object({
+  userId: z27.string(),
   status: presenceStatusSchema,
   location: presenceLocationSchema,
-  ts: z26.string()
+  ts: z27.string()
 });
-var updatePresenceRequestSchema = z26.object({
+var updatePresenceRequestSchema = z27.object({
   status: presenceStatusSchema,
   location: presenceLocationSchema.optional()
 });
 
 // ../shared/src/routes/review-messages.ts
-import { z as z27 } from "zod";
-var sendPullRequestReviewMessageRequestSchema = z27.object({
+import { z as z28 } from "zod";
+var sendPullRequestReviewMessageRequestSchema = z28.object({
   ...sendChatMessageRequestSchema.pick({
     message: true,
     messageId: true,
@@ -19676,8 +20202,8 @@ var sendPullRequestReviewMessageRequestSchema = z27.object({
     ultrafastMode: true
   }).shape,
   /** Starts a new chat instead of continuing the PR's review chat. The provider only applies to a new chat. */
-  newChat: z27.boolean().optional(),
-  provider: z27.enum(VALID_AGENT_PROVIDERS).optional()
+  newChat: z28.boolean().optional(),
+  provider: z28.enum(VALID_AGENT_PROVIDERS).optional()
 });
 
 // ../shared/src/audit-log.ts
@@ -19898,30 +20424,30 @@ function isSkillRegistryManifest(value) {
 }
 
 // ../shared/src/routes/variable-requests.ts
-import { z as z28 } from "zod";
+import { z as z29 } from "zod";
 var VARIABLE_REQUEST_WAIT = { defaultMs: 10 * 6e4, maxMs: 30 * 6e4, pollMs: 3e3, waiterStaleMs: 15e3 };
 var VARIABLE_REQUEST_DESTINATIONS = ["environment", "workspace"];
-var requestedVariableSchema = z28.object({
-  key: z28.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(ENVIRONMENT_SETUP_LIMITS.variableKeyChars),
-  required: z28.boolean(),
-  replace: z28.boolean().optional()
+var requestedVariableSchema = z29.object({
+  key: z29.string().regex(VARIABLE_KEY_RE, "must be a valid environment variable name").max(ENVIRONMENT_SETUP_LIMITS.variableKeyChars),
+  required: z29.boolean(),
+  replace: z29.boolean().optional()
 });
-var requestedVariablesSchema = z28.array(requestedVariableSchema).min(1, "must not be empty").max(ENVIRONMENT_SETUP_LIMITS.variables).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys");
-var createVariableRequestSchema = z28.object({
+var requestedVariablesSchema = z29.array(requestedVariableSchema).min(1, "must not be empty").max(ENVIRONMENT_SETUP_LIMITS.variables).refine((variables) => new Set(variables.map((variable) => variable.key)).size === variables.length, "must have unique keys");
+var createVariableRequestSchema = z29.object({
   variables: requestedVariablesSchema,
-  reason: z28.string().trim().max(500).nullish().transform((value) => value || null),
-  wait: z28.boolean().default(true)
+  reason: z29.string().trim().max(500).nullish().transform((value) => value || null),
+  wait: z29.boolean().default(true)
 });
-var respondVariableRequestSchema = z28.discriminatedUnion("action", [
-  z28.object({
-    action: z28.literal("provide"),
-    destination: z28.enum(VARIABLE_REQUEST_DESTINATIONS),
+var respondVariableRequestSchema = z29.discriminatedUnion("action", [
+  z29.object({
+    action: z29.literal("provide"),
+    destination: z29.enum(VARIABLE_REQUEST_DESTINATIONS),
     /** Defaults to the workspace's environment, so older clients keep saving there. */
-    environment_ids: z28.array(z28.string().uuid()).optional(),
-    overwrite: z28.boolean().optional(),
-    values: z28.record(z28.string().regex(VARIABLE_KEY_RE), z28.string())
+    environment_ids: z29.array(z29.string().uuid()).optional(),
+    overwrite: z29.boolean().optional(),
+    values: z29.record(z29.string().regex(VARIABLE_KEY_RE), z29.string())
   }),
-  z28.object({ action: z28.literal("skip") })
+  z29.object({ action: z29.literal("skip") })
 ]);
 
 export {
@@ -20072,6 +20598,7 @@ export {
   codexTurnFromEvent,
   codexTranscriptToEvents,
   steerQueuedInOrder,
+  respondToolInputRequestSchema,
   isLatestChatHistoryPage,
   getChatHistoryPageSenders,
   parseChatHistoryCursor,
@@ -20127,6 +20654,7 @@ export {
   formatChatForkHandoffMessage,
   formatChatForkUpdateMessage,
   threadHandoffText,
+  isToolInputQuestion,
   fileContentDiff,
   skillNamesFromCommand,
   parseMcpToolName,
@@ -20136,6 +20664,7 @@ export {
   learnedSkillsManifestSchema,
   learnedSkillFormatInstruction,
   areUserMessagesWithinMatchWindow,
+  currentStepLabel,
   codexPromptTurnId,
   extractErrorText,
   isTransientErrorText,