@autohq/cli 0.1.592 → 0.1.594

package/dist/agent-bridge.js

@@ -37736,7 +37736,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.592",
+  version: "0.1.594",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"
@@ -40412,6 +40412,35 @@ var TranscriptActivitySchema = external_exports.discriminatedUnion("type", [
   external_exports.object({
     type: external_exports.literal("run"),
     command: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("edit"),
+    paths: external_exports.array(external_exports.string()).optional()
+  }),
+  external_exports.object({
+    type: external_exports.literal("tool"),
+    name: external_exports.string(),
+    provider: external_exports.string().optional()
+  }),
+  external_exports.object({
+    type: external_exports.literal("webSearch"),
+    query: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("imageView"),
+    path: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("collaboration"),
+    action: external_exports.string()
+  }),
+  external_exports.object({
+    type: external_exports.literal("wait"),
+    durationMs: external_exports.number().nonnegative()
+  }),
+  external_exports.object({
+    type: external_exports.literal("imageGeneration"),
+    savedPath: external_exports.string().optional()
   })
 ]);
 var TranscriptToolMetadataSchema = external_exports.object({
@@ -40499,13 +40528,74 @@ var CodexMcpToolCallItemSchema = external_exports.object({
   error: external_exports.object({ message: external_exports.string() }).passthrough().nullish(),
   durationMs: external_exports.number().nonnegative().nullish()
 }).passthrough();
+var CodexDynamicToolCallItemSchema = external_exports.object({
+  type: external_exports.literal("dynamicToolCall"),
+  id: external_exports.string(),
+  namespace: external_exports.string().nullish(),
+  tool: external_exports.string().default(""),
+  arguments: external_exports.unknown().optional(),
+  status: external_exports.string().optional(),
+  contentItems: external_exports.array(external_exports.unknown()).nullish(),
+  success: external_exports.boolean().nullish(),
+  durationMs: external_exports.number().nonnegative().nullish()
+}).passthrough();
+var CodexCollabAgentToolCallItemSchema = external_exports.object({
+  type: external_exports.literal("collabAgentToolCall"),
+  id: external_exports.string(),
+  tool: external_exports.string(),
+  status: external_exports.string().optional(),
+  senderThreadId: external_exports.string().default(""),
+  receiverThreadIds: external_exports.array(external_exports.string()).default([]),
+  prompt: external_exports.string().nullish(),
+  model: external_exports.string().nullish(),
+  reasoningEffort: external_exports.string().nullish(),
+  agentsStates: external_exports.record(external_exports.string(), external_exports.unknown()).default({})
+}).passthrough();
+var CodexSubAgentActivityItemSchema = external_exports.object({
+  type: external_exports.literal("subAgentActivity"),
+  id: external_exports.string(),
+  kind: external_exports.string(),
+  agentThreadId: external_exports.string(),
+  agentPath: external_exports.string()
+}).passthrough();
+var CodexWebSearchItemSchema = external_exports.object({
+  type: external_exports.literal("webSearch"),
+  id: external_exports.string(),
+  query: external_exports.string().default(""),
+  action: external_exports.unknown().nullish()
+}).passthrough();
+var CodexImageViewItemSchema = external_exports.object({
+  type: external_exports.literal("imageView"),
+  id: external_exports.string(),
+  path: external_exports.string()
+}).passthrough();
+var CodexSleepItemSchema = external_exports.object({
+  type: external_exports.literal("sleep"),
+  id: external_exports.string(),
+  durationMs: external_exports.number().nonnegative()
+}).passthrough();
+var CodexImageGenerationItemSchema = external_exports.object({
+  type: external_exports.literal("imageGeneration"),
+  id: external_exports.string(),
+  status: external_exports.string().optional(),
+  revisedPrompt: external_exports.string().nullish(),
+  result: external_exports.string().default(""),
+  savedPath: external_exports.string().optional()
+}).passthrough();
 var CodexItemSchema = external_exports.discriminatedUnion("type", [
   CodexUserMessageItemSchema,
   CodexAgentMessageItemSchema,
   CodexReasoningItemSchema,
   CodexCommandExecutionItemSchema,
   CodexFileChangeItemSchema,
-  CodexMcpToolCallItemSchema
+  CodexMcpToolCallItemSchema,
+  CodexDynamicToolCallItemSchema,
+  CodexCollabAgentToolCallItemSchema,
+  CodexSubAgentActivityItemSchema,
+  CodexWebSearchItemSchema,
+  CodexImageViewItemSchema,
+  CodexSleepItemSchema,
+  CodexImageGenerationItemSchema
 ]);
 var OptionalCodexItemSchema = external_exports.unknown().transform((value2) => {
   const parsed = CodexItemSchema.safeParse(value2);
@@ -82875,67 +82965,263 @@ var defaultDownload2 = createDownload();
 import { Buffer as Buffer2 } from "buffer";
 var AGENT_BRIDGE_OUTPUT_MAX_ENVELOPE_BYTES = 512 * 1024;
 var AGENT_BRIDGE_OUTPUT_QUARANTINE_MAX_ENVELOPE_BYTES = 8 * 1024;
-var MIN_STRING_BUDGET_CHARS = 64;
+var MAX_TARGETED_PAYLOAD_NOTICES = 4;
+var PAYLOAD_FIELD_RULES = {
+  output: { label: "tool output", priority: 0 },
+  errorText: { label: "tool error", priority: 0 },
+  details: { label: "tool error details", priority: 1 },
+  input: { label: "tool input", priority: 1 },
+  text: { label: "text content", priority: 2 },
+  delta: { label: "streamed content", priority: 2 },
+  data: { label: "data content", priority: 2 },
+  metadata: { label: "message metadata", priority: 3 },
+  messageMetadata: { label: "message metadata", priority: 3 },
+  providerMetadata: { label: "provider metadata", priority: 3 },
+  callProviderMetadata: { label: "provider metadata", priority: 3 },
+  toolMetadata: { label: "tool metadata", priority: 3 }
+};
+var STRUCTURAL_STRING_FIELDS = /* @__PURE__ */ new Set([
+  "type",
+  "id",
+  "role",
+  "state",
+  "status",
+  "name",
+  "toolName",
+  "toolCallId",
+  "toolUseId",
+  "messageId",
+  "sourceId",
+  "approvalId",
+  "mediaType",
+  "url",
+  "title",
+  "createdAt",
+  "completedAt"
+]);
 function boundOutputEnvelope(envelope, maxBytes = AGENT_BRIDGE_OUTPUT_MAX_ENVELOPE_BYTES) {
   const originalBytes = serializedByteLength(envelope);
   if (originalBytes <= maxBytes) {
     return { envelope, originalBytes, truncated: false };
   }
-  for (let budget = initialStringBudget(maxBytes); budget >= MIN_STRING_BUDGET_CHARS; budget = Math.floor(budget / 8)) {
-    const candidate = truncateLongStrings(envelope, budget);
-    if (serializedByteLength(candidate) <= maxBytes) {
-      return {
-        envelope: RuntimeBridgeOutputEnvelopeSchema.parse(candidate),
-        originalBytes,
-        truncated: true
-      };
-    }
+  const targeted = truncatePayloads(envelope, maxBytes);
+  if (targeted) {
+    return {
+      envelope: RuntimeBridgeOutputEnvelopeSchema.parse(targeted),
+      originalBytes,
+      truncated: true
+    };
   }
   return {
     envelope: RuntimeBridgeOutputEnvelopeSchema.parse(
-      replacePayloadWithMarker(envelope, originalBytes)
+      replacePayloadWithMarker(envelope)
     ),
     originalBytes,
     truncated: true
   };
 }
-function serializedByteLength(value2) {
-  return Buffer2.byteLength(JSON.stringify(value2), "utf8");
-}
-function initialStringBudget(maxBytes) {
-  return Math.max(MIN_STRING_BUDGET_CHARS, Math.floor(maxBytes / 8));
-}
-function truncateLongStrings(value2, budget) {
-  if (typeof value2 === "string") {
-    if (value2.length <= budget) {
-      return value2;
+function truncatePayloads(envelope, maxBytes) {
+  const candidateEnvelope = structuredClone(envelope);
+  const candidates = collectPayloadCandidates(envelope);
+  for (let noticeCount = 0; noticeCount < MAX_TARGETED_PAYLOAD_NOTICES; noticeCount += 1) {
+    const currentBytes = serializedByteLength(candidateEnvelope);
+    if (currentBytes <= maxBytes) {
+      return candidateEnvelope;
+    }
+    const candidate = takePayloadCandidate(candidates, currentBytes - maxBytes);
+    if (!candidate) {
+      return null;
     }
-    return `${value2.slice(0, budget)}${truncationMarker(value2.length - budget)}`;
+    setValueAtPath(
+      candidateEnvelope,
+      candidate.path,
+      truncationNotice(candidate, "")
+    );
+    if (serializedByteLength(candidateEnvelope) <= maxBytes) {
+      maximizePreview(candidateEnvelope, candidate, maxBytes);
+      return candidateEnvelope;
+    }
+  }
+  return serializedByteLength(candidateEnvelope) <= maxBytes ? candidateEnvelope : null;
+}
+function collectPayloadCandidates(envelope) {
+  let seeds;
+  switch (envelope.type) {
+    case "conversation.entry":
+      seeds = collectJsonPayloadCandidates(envelope.content, ["content"]);
+      break;
+    case "conversation.delta":
+      seeds = collectJsonPayloadCandidates(envelope.delta, ["delta"]);
+      break;
+    case "ui.message.chunk":
+      seeds = collectJsonPayloadCandidates(envelope.chunk, ["chunk"]);
+      break;
+    case "ui.message.part":
+      seeds = collectJsonPayloadCandidates(envelope.part, ["part"]);
+      if (envelope.messageMetadata !== void 0) {
+        seeds.push(
+          toCandidateSeed(
+            ["messageMetadata"],
+            "message metadata",
+            3,
+            envelope.messageMetadata
+          )
+        );
+      }
+      break;
+    case "ui.message.completed":
+      seeds = collectJsonPayloadCandidates(envelope.message, ["message"]);
+      break;
+    case "runtime.liveness":
+    case "runtime.usage_turn":
+      return [];
   }
+  return seeds.map(toPayloadCandidate).filter((candidate) => candidate.potentialSavings > 0);
+}
+function collectJsonPayloadCandidates(value2, path2) {
   if (Array.isArray(value2)) {
-    return value2.map((item) => truncateLongStrings(item, budget));
+    return value2.flatMap(
+      (item, index) => collectJsonPayloadCandidates(item, [...path2, index])
+    );
   }
   if (typeof value2 === "object" && value2 !== null) {
-    return Object.fromEntries(
-      Object.entries(value2).map(([key, item]) => [
-        key,
-        truncateLongStrings(item, budget)
-      ])
+    return Object.entries(value2).flatMap(([key, item]) => {
+      const itemPath = [...path2, key];
+      const rule = PAYLOAD_FIELD_RULES[key];
+      if (rule) {
+        return [toCandidateSeed(itemPath, rule.label, rule.priority, item)];
+      }
+      if (typeof item === "string" && !STRUCTURAL_STRING_FIELDS.has(key)) {
+        return [toCandidateSeed(itemPath, "content", 4, item)];
+      }
+      return collectJsonPayloadCandidates(item, itemPath);
+    });
+  }
+  return [];
+}
+function toCandidateSeed(path2, label, priority, value2) {
+  return { path: path2, label, priority, value: value2 };
+}
+function toPayloadCandidate(seed, order) {
+  const preview = payloadPreview(seed.value);
+  const originalBytes = Buffer2.byteLength(preview, "utf8");
+  const candidate = {
+    ...seed,
+    order,
+    preview,
+    originalBytes,
+    potentialSavings: 0
+  };
+  return {
+    ...candidate,
+    potentialSavings: serializedByteLength(seed.value) - serializedByteLength(truncationNotice(candidate, ""))
+  };
+}
+function payloadPreview(value2) {
+  if (typeof value2 === "string") {
+    return value2;
+  }
+  return JSON.stringify(value2) ?? String(value2);
+}
+function takePayloadCandidate(candidates, bytesToRemove) {
+  const sufficient = candidates.filter(
+    (candidate) => candidate.potentialSavings >= bytesToRemove
+  );
+  const pool = sufficient.length > 0 ? sufficient : candidates;
+  pool.sort((left, right) => {
+    if (sufficient.length > 0 && left.priority !== right.priority) {
+      return left.priority - right.priority;
+    }
+    if (left.potentialSavings !== right.potentialSavings) {
+      return right.potentialSavings - left.potentialSavings;
+    }
+    if (left.priority !== right.priority) {
+      return left.priority - right.priority;
+    }
+    return left.order - right.order;
+  });
+  const selected = pool[0];
+  if (!selected) {
+    return void 0;
+  }
+  const candidateIndex = candidates.indexOf(selected);
+  candidates.splice(candidateIndex, 1);
+  return selected;
+}
+function maximizePreview(envelope, candidate, maxBytes) {
+  let bestPrefix = "";
+  let lower = 0;
+  let upper = Math.max(0, candidate.preview.length - 1);
+  while (lower <= upper) {
+    const midpoint = Math.floor((lower + upper) / 2);
+    const prefix = safeStringPrefix(candidate.preview, midpoint);
+    setValueAtPath(
+      envelope,
+      candidate.path,
+      truncationNotice(candidate, prefix)
     );
+    if (serializedByteLength(envelope) <= maxBytes) {
+      bestPrefix = prefix;
+      lower = midpoint + 1;
+    } else {
+      upper = midpoint - 1;
+    }
   }
-  return value2;
+  setValueAtPath(
+    envelope,
+    candidate.path,
+    truncationNotice(candidate, bestPrefix)
+  );
+}
+function safeStringPrefix(value2, length) {
+  let safeLength = Math.min(length, value2.length);
+  if (safeLength > 0) {
+    const lastCodeUnit = value2.charCodeAt(safeLength - 1);
+    if (lastCodeUnit >= 55296 && lastCodeUnit <= 56319) {
+      safeLength -= 1;
+    }
+  }
+  return value2.slice(0, safeLength);
+}
+function setValueAtPath(root, path2, value2) {
+  let parent = root;
+  for (const segment of path2.slice(0, -1)) {
+    if (typeof parent !== "object" || parent === null) {
+      throw new Error("Invalid payload candidate path");
+    }
+    parent = parent[segment];
+  }
+  if (typeof parent !== "object" || parent === null) {
+    throw new Error("Invalid payload candidate parent");
+  }
+  const finalSegment = path2.at(-1);
+  if (finalSegment === void 0) {
+    throw new Error("Payload candidate path cannot be empty");
+  }
+  parent[finalSegment] = value2;
 }
-function truncationMarker(droppedChars) {
-  return `\u2026 [agent-bridge truncated ${droppedChars} chars: output exceeded the bridge envelope size limit]`;
+function truncationNotice(candidate, preview) {
+  const keptBytes = Buffer2.byteLength(preview, "utf8");
+  const omittedBytes = candidate.originalBytes - keptBytes;
+  const separator = preview.length > 0 ? "\n" : "";
+  return `${preview}${separator}[agent-bridge ${candidate.label} truncated: original ${candidate.originalBytes} UTF-8 bytes; kept ${keptBytes}; omitted ${omittedBytes}. Omitted content was not persisted in this transcript.]`;
+}
+function serializedByteLength(value2) {
+  const serialized = JSON.stringify(value2);
+  return serialized === void 0 ? 0 : Buffer2.byteLength(serialized, "utf8");
 }
-function replacePayloadWithMarker(envelope, originalBytes) {
-  const text2 = `[agent-bridge removed a ${originalBytes}-byte payload: it exceeded the bridge envelope size limit and could not be truncated]`;
+function replacePayloadWithMarker(envelope) {
   switch (envelope.type) {
-    case "conversation.entry":
+    case "conversation.entry": {
+      const text2 = payloadRemovalNotice(envelope.content);
       return { ...envelope, content: { parts: [{ type: "text", text: text2 }] } };
-    case "conversation.delta":
+    }
+    case "conversation.delta": {
+      const text2 = payloadRemovalNotice(envelope.delta);
       return { ...envelope, delta: { type: "text", text: text2 } };
-    case "ui.message.chunk":
+    }
+    case "ui.message.chunk": {
+      const text2 = payloadRemovalNotice(envelope.chunk);
       return {
         ...envelope,
         chunk: {
@@ -82944,11 +83230,17 @@ function replacePayloadWithMarker(envelope, originalBytes) {
           delta: text2
         }
       };
+    }
     case "ui.message.part": {
       const { messageMetadata: _dropped, ...rest } = envelope;
+      const text2 = payloadRemovalNotice({
+        part: envelope.part,
+        ...envelope.messageMetadata === void 0 ? {} : { messageMetadata: envelope.messageMetadata }
+      });
       return { ...rest, part: { type: "text", text: text2, state: "done" } };
     }
-    case "ui.message.completed":
+    case "ui.message.completed": {
+      const text2 = payloadRemovalNotice(envelope.message);
       return {
         ...envelope,
         message: {
@@ -82957,11 +83249,16 @@ function replacePayloadWithMarker(envelope, originalBytes) {
           parts: [{ type: "text", text: text2, state: "done" }]
         }
       };
+    }
     case "runtime.liveness":
     case "runtime.usage_turn":
       return envelope;
   }
 }
+function payloadRemovalNotice(payload) {
+  const originalBytes = Buffer2.byteLength(payloadPreview(payload), "utf8");
+  return `[agent-bridge payload removed: original ${originalBytes} UTF-8 bytes; kept 0; omitted ${originalBytes}. Omitted content was not persisted in this transcript. Targeted truncation could not fit the bridge envelope.]`;
+}
 
 // src/commands/agent-bridge/harness/ui-message-part-tracker.ts
 var UiMessagePartTracker = class {
@@ -84522,7 +84819,10 @@ var ClaudeCodeProjector = class {
       this.activeParts.clear();
       this.activeToolInputs.clear();
       this.interruptMarkerSeen = false;
-      return this.ensureResponseStarted(this.currentMessageId);
+      return [
+        ...this.ensureResponseStarted(this.currentMessageId),
+        uiChunk({ type: "start-step" })
+      ];
     }
     if (message.event.type === "message_stop") {
       const outputs = [
@@ -84695,7 +84995,8 @@ var ClaudeCodeProjector = class {
     const messageId = messageProjection?.messageId ?? toolCallProjections.find((projection) => projection.messageId)?.messageId ?? UNKNOWN_MESSAGE_ID;
     const standalone = this.activeResponseMessageId === null;
     const outputs = [
-      ...this.ensureResponseStarted(messageId)
+      ...this.ensureResponseStarted(messageId),
+      uiChunk({ type: "start-step" })
     ];
     if (messageProjection) {
       outputs.push(...messagePartChunks(messageProjection));
@@ -84703,7 +85004,8 @@ var ClaudeCodeProjector = class {
     outputs.push(
       ...toolCallProjections.flatMap(
         (projection) => toolCallChunks(projection)
-      )
+      ),
+      uiChunk({ type: "finish-step" })
     );
     if (standalone && toolCallProjections.length === 0) {
       outputs.push(uiChunk({ type: "finish", finishReason: "stop" }));
@@ -87245,12 +87547,14 @@ var CodexProjector = class {
   activeToolCalls = /* @__PURE__ */ new Set();
   activeToolMetadata = /* @__PURE__ */ new Map();
   activeToolOutput = /* @__PURE__ */ new Map();
+  activeSteps = /* @__PURE__ */ new Set();
   activeResponseMessageId = null;
   project(notification) {
     switch (notification.type) {
       case "agentMessageDelta":
         return [
           ...this.ensureResponseStarted(notification.itemId),
+          ...this.ensureStepStarted(notification.itemId),
           ...this.projectAgentMessageDelta(
             notification.itemId,
             notification.delta
@@ -87277,7 +87581,10 @@ var CodexProjector = class {
       case "itemCompleted":
         return this.projectItem(notification.item, "completed");
       case "turnCompleted": {
-        const outputs = this.endAllReasoningParts();
+        const outputs = [
+          ...this.endAllReasoningParts(),
+          ...this.finishAllSteps()
+        ];
         this.activeResponseMessageId = null;
         this.activeAgentMessages.clear();
         this.agentMessagePhases.clear();
@@ -87360,7 +87667,10 @@ var CodexProjector = class {
     if (delta.length === 0) {
       return [];
     }
-    const outputs = this.ensureResponseStarted(itemId);
+    const outputs = [
+      ...this.ensureResponseStarted(itemId),
+      ...this.ensureStepStarted(itemId)
+    ];
     const active = this.activeReasoningParts.get(itemId);
     if (active && active.summaryIndex !== summaryIndex) {
       outputs.push(...this.endReasoningPart(itemId));
@@ -87407,10 +87717,15 @@ var CodexProjector = class {
         }
         return [
           ...this.ensureResponseStarted(item.id),
+          ...this.ensureStepStarted(item.id),
           ...this.projectAgentMessageItem(item, phase)
         ];
       case "reasoning":
-        return this.projectReasoningItem(item, phase);
+        return [
+          ...this.ensureResponseStarted(item.id),
+          ...this.ensureStepStarted(item.id),
+          ...this.projectReasoningItem(item, phase)
+        ];
       case "commandExecution":
         return this.projectToolItem({
           phase,
@@ -87440,7 +87755,14 @@ var CodexProjector = class {
           isDenied: isDeclinedStatus(item.status),
           isError: isFailedStatus(item.status),
           title: "apply_patch",
-          toolMetadata: statusMetadata(item.status)
+          toolMetadata: statusMetadata(item.status, {
+            activities: [
+              {
+                type: "edit",
+                paths: fileChangePaths(item.changes)
+              }
+            ]
+          })
         });
       case "mcpToolCall":
         if (isAskUserMcpTool(item.server, item.tool)) {
@@ -87460,6 +87782,132 @@ var CodexProjector = class {
             ...item.durationMs != null ? { durationMs: item.durationMs } : {}
           })
         });
+      case "dynamicToolCall": {
+        const name23 = item.namespace ? `${item.namespace}.${item.tool}` : item.tool;
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: name23,
+          input: toJsonValue(item.arguments),
+          output: {
+            contentItems: toJsonValue(item.contentItems),
+            success: item.success
+          },
+          isError: isFailedStatus(item.status) || item.success === false,
+          title: name23,
+          toolMetadata: statusMetadata(item.status, {
+            tool: item.tool,
+            ...item.namespace ? { server: item.namespace } : {},
+            activities: [
+              {
+                type: "tool",
+                name: item.tool,
+                ...item.namespace ? { provider: item.namespace } : {}
+              }
+            ],
+            ...item.durationMs != null ? { durationMs: item.durationMs } : {}
+          })
+        });
+      }
+      case "collabAgentToolCall":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: `collaboration.${item.tool}`,
+          input: {
+            prompt: item.prompt,
+            receiverThreadIds: item.receiverThreadIds,
+            model: item.model,
+            reasoningEffort: item.reasoningEffort
+          },
+          output: {
+            status: item.status ?? "unknown",
+            agentsStates: item.agentsStates
+          },
+          isError: isFailedStatus(item.status),
+          title: item.tool,
+          toolMetadata: statusMetadata(item.status, {
+            activities: [{ type: "collaboration", action: item.tool }]
+          })
+        });
+      case "subAgentActivity":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: "collaboration.sub_agent_activity",
+          input: {
+            kind: item.kind,
+            agentThreadId: item.agentThreadId,
+            agentPath: item.agentPath
+          },
+          output: { status: "completed" },
+          isError: false,
+          title: item.kind,
+          toolMetadata: {
+            activities: [{ type: "collaboration", action: item.kind }]
+          }
+        });
+      case "webSearch":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: "web_search",
+          input: { query: item.query, action: toJsonValue(item.action) },
+          output: { status: "completed" },
+          isError: false,
+          title: item.query || "Web search",
+          toolMetadata: {
+            activities: [{ type: "webSearch", query: item.query }]
+          }
+        });
+      case "imageView":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: "view_image",
+          input: { path: item.path },
+          output: { status: "viewed" },
+          isError: false,
+          title: item.path,
+          toolMetadata: {
+            activities: [{ type: "imageView", path: item.path }]
+          }
+        });
+      case "sleep":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: "wait",
+          input: { durationMs: item.durationMs },
+          output: { status: "completed" },
+          isError: false,
+          title: "Wait",
+          toolMetadata: {
+            activities: [{ type: "wait", durationMs: item.durationMs }],
+            durationMs: item.durationMs
+          }
+        });
+      case "imageGeneration":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: "image_generation",
+          input: { prompt: item.revisedPrompt },
+          output: {
+            result: item.result,
+            ...item.savedPath ? { savedPath: item.savedPath } : {}
+          },
+          isError: isFailedStatus(item.status),
+          title: item.revisedPrompt ?? "Generate image",
+          toolMetadata: statusMetadata(item.status, {
+            activities: [
+              {
+                type: "imageGeneration",
+                ...item.savedPath ? { savedPath: item.savedPath } : {}
+              }
+            ]
+          })
+        });
       default:
         return [];
     }
@@ -87467,6 +87915,7 @@ var CodexProjector = class {
   projectToolItem(input) {
     const outputs = [];
     outputs.push(...this.ensureResponseStarted(input.itemId));
+    outputs.push(...this.ensureStepStarted(input.itemId));
     if (input.toolMetadata) {
       this.activeToolMetadata.set(input.itemId, input.toolMetadata);
     }
@@ -87482,7 +87931,7 @@ var CodexProjector = class {
       input.output = this.activeToolOutput.get(input.itemId)?.output ?? "";
     }
     outputs.push(toolOutputChunk(input));
-    outputs.push(uiChunk2({ type: "finish-step" }));
+    outputs.push(...this.finishStep(input.itemId));
     this.activeToolCalls.delete(input.itemId);
     this.activeToolMetadata.delete(input.itemId);
     this.activeToolOutput.delete(input.itemId);
@@ -87515,7 +87964,7 @@ var CodexProjector = class {
     }
     outputs.push(
       textBoundaryChunk("text-end", item.id, messagePhase),
-      uiChunk2({ type: "finish-step" })
+      ...this.finishStep(item.id)
     );
     this.activeAgentMessages.delete(item.id);
     this.agentMessagePhases.delete(item.id);
@@ -87530,15 +87979,11 @@ var CodexProjector = class {
     this.streamedReasoningIndexes.delete(item.id);
     if (streamedIndexes && streamedIndexes.size > 0) {
       outputs.push(...reasoningItemChunks(item, streamedIndexes));
-      outputs.push(uiChunk2({ type: "finish-step" }));
+      outputs.push(...this.finishStep(item.id));
       return outputs;
     }
     const completedChunks = reasoningItemChunks(item);
-    return completedChunks.length > 0 ? [
-      ...this.ensureResponseStarted(item.id),
-      ...completedChunks,
-      uiChunk2({ type: "finish-step" })
-    ] : [];
+    return [...completedChunks, ...this.finishStep(item.id)];
   }
   endReasoningPart(itemId) {
     const active = this.activeReasoningParts.get(itemId);
@@ -87560,6 +88005,26 @@ var CodexProjector = class {
     this.activeResponseMessageId = messageId;
     return [uiChunk2({ type: "start", messageId })];
   }
+  ensureStepStarted(itemId) {
+    if (this.activeSteps.has(itemId)) {
+      return [];
+    }
+    this.activeSteps.add(itemId);
+    return [uiChunk2({ type: "start-step" })];
+  }
+  finishStep(itemId) {
+    if (!this.activeSteps.delete(itemId)) {
+      return [];
+    }
+    return [uiChunk2({ type: "finish-step" })];
+  }
+  finishAllSteps() {
+    const outputs = [...this.activeSteps].map(
+      () => uiChunk2({ type: "finish-step" })
+    );
+    this.activeSteps.clear();
+    return outputs;
+  }
 };
 function emptyToolOutput() {
   return { bytes: 0, output: "", truncated: false };
@@ -87683,6 +88148,14 @@ function commandActivities(actions) {
     }
   });
 }
+function fileChangePaths(changes) {
+  return changes.flatMap((change) => {
+    if (typeof change !== "object" || change === null || !("path" in change) || typeof change.path !== "string") {
+      return [];
+    }
+    return [change.path];
+  });
+}
 function turnCompletionEntry(notification) {
   if (notification.status === "failed") {
     const detail = notification.errorMessage ?? "unknown error";