@autohq/cli 0.1.282 → 0.1.283

package/dist/index.js

@@ -15840,7 +15840,7 @@ var init_chat = __esm({
 });
 
 // ../../packages/schemas/src/conversation.ts
-var CONVERSATION_ROLES, CONVERSATION_ENTRY_KINDS, CONVERSATION_ENTRY_STATUSES, UNKNOWN_MESSAGE_ID, ConversationRoleSchema, ConversationEntryKindSchema, ConversationEntryStatusSchema, ConversationTextContentPartSchema, ConversationReasoningContentPartSchema, ConversationToolCallContentPartSchema, ConversationToolResultContentPartSchema, ConversationQuestionOptionSchema, ConversationQuestionSchema, ConversationQuestionContentPartSchema, ConversationContentPartSchema, ConversationEntryContentSchema, ConversationEntryEventSchema, ConversationTextDeltaSchema, ConversationReasoningDeltaSchema, ConversationDeltaSchema, ConversationDeltaEventSchema, ConversationRealtimeEventSchema;
+var CONVERSATION_ROLES, CONVERSATION_ENTRY_KINDS, CONVERSATION_ENTRY_STATUSES, UNKNOWN_MESSAGE_ID, ConversationRoleSchema, ConversationEntryKindSchema, ConversationEntryStatusSchema, ConversationTextContentPartSchema, ConversationReasoningContentPartSchema, ConversationToolCallContentPartSchema, ConversationToolResultContentPartSchema, ConversationQuestionOptionSchema, ConversationQuestionSchema, ConversationQuestionContentPartSchema, ConversationUiMessageContentPartSchema, ConversationContentPartSchema, ConversationEntryContentSchema, ConversationEntryEventSchema, ConversationTextDeltaSchema, ConversationReasoningDeltaSchema, ConversationDeltaSchema, ConversationDeltaEventSchema, ConversationUiMessageChunkEventSchema, ConversationRealtimeEventSchema;
 var init_conversation = __esm({
   "../../packages/schemas/src/conversation.ts"() {
     "use strict";
@@ -15906,12 +15906,17 @@ var init_conversation = __esm({
       toolCallId: external_exports.string().min(1).nullable(),
       questions: external_exports.array(ConversationQuestionSchema)
     });
+    ConversationUiMessageContentPartSchema = external_exports.object({
+      type: external_exports.literal("ui_message"),
+      message: JsonValueSchema
+    });
     ConversationContentPartSchema = external_exports.discriminatedUnion("type", [
       ConversationTextContentPartSchema,
       ConversationReasoningContentPartSchema,
       ConversationToolCallContentPartSchema,
       ConversationToolResultContentPartSchema,
-      ConversationQuestionContentPartSchema
+      ConversationQuestionContentPartSchema,
+      ConversationUiMessageContentPartSchema
     ]);
     ConversationEntryContentSchema = external_exports.object({
       parts: external_exports.array(ConversationContentPartSchema)
@@ -15953,9 +15958,18 @@ var init_conversation = __esm({
       delta: ConversationDeltaSchema,
       createdAt: external_exports.string().datetime()
     });
+    ConversationUiMessageChunkEventSchema = external_exports.object({
+      type: external_exports.literal("ui.message.chunk"),
+      id: external_exports.string().min(1),
+      sessionId: SessionIdSchema,
+      sequence: external_exports.number().int().nonnegative(),
+      chunk: JsonValueSchema,
+      createdAt: external_exports.string().datetime()
+    });
     ConversationRealtimeEventSchema = external_exports.discriminatedUnion("type", [
       ConversationEntryEventSchema,
-      ConversationDeltaEventSchema
+      ConversationDeltaEventSchema,
+      ConversationUiMessageChunkEventSchema
     ]);
   }
 });
@@ -16064,6 +16078,7 @@ function assistantContentProjections(message, messageId) {
       projections.push({
         role: "assistant",
         kind: "tool_call",
+        ...messageId ? { messageId } : {},
         content: {
           parts: [
             {
@@ -16305,87 +16320,6 @@ function parseCodexServerFrame(raw) {
   const notification = parseNotification(frame.method, frame.params);
   return notification ? { kind: "notification", notification } : { kind: "ignored" };
 }
-function projectCodexItem(input) {
-  const { item, phase } = input;
-  switch (item.type) {
-    case "agentMessage":
-      return phase === "completed" && item.text.length > 0 ? [
-        {
-          role: "assistant",
-          kind: "message",
-          messageId: item.id,
-          content: textContent2(item.text)
-        }
-      ] : [];
-    case "reasoning": {
-      if (phase !== "completed") {
-        return [];
-      }
-      const text = item.summary.map((line) => line.trim()).filter(Boolean).join("\n\n");
-      return text.length > 0 ? [
-        {
-          role: "assistant",
-          kind: "message",
-          messageId: item.id,
-          content: reasoningContent(text)
-        }
-      ] : [];
-    }
-    case "commandExecution":
-      return toolProjection({
-        phase,
-        itemId: item.id,
-        name: "shell",
-        input: {
-          command: item.command,
-          ...item.cwd ? { cwd: item.cwd } : {}
-        },
-        output: item.aggregatedOutput ?? "",
-        isError: isFailedStatus(item.status) || (item.exitCode ?? 0) !== 0
-      });
-    case "fileChange":
-      return toolProjection({
-        phase,
-        itemId: item.id,
-        name: "apply_patch",
-        input: { changes: toJsonValue(item.changes) },
-        output: { status: item.status ?? "unknown" },
-        isError: isFailedStatus(item.status)
-      });
-    case "mcpToolCall":
-      return toolProjection({
-        phase,
-        itemId: item.id,
-        name: `${item.server}.${item.tool}`,
-        input: toJsonValue(item.arguments),
-        output: item.error ? { error: item.error.message } : toJsonValue(item.result),
-        isError: isFailedStatus(item.status) || item.error != null
-      });
-    default:
-      return [];
-  }
-}
-function projectCodexApproval(request) {
-  const subject = request.type === "commandExecution" ? `run the command: ${request.command ?? "(unknown command)"}` : "apply file changes";
-  const question = {
-    question: request.reason ? `Codex requests approval to ${subject}. ${request.reason}` : `Codex requests approval to ${subject}.`,
-    header: "Approval",
-    options: [
-      { label: APPROVE_OPTION_LABEL, description: "Allow this action." },
-      { label: DECLINE_OPTION_LABEL, description: "Reject this action." }
-    ],
-    multiSelect: false
-  };
-  return {
-    role: "assistant",
-    kind: "question",
-    content: {
-      parts: [
-        { type: "question", toolCallId: request.itemId, questions: [question] }
-      ]
-    }
-  };
-}
 function codexApprovalDecision(input) {
   const values = [...Object.values(input.answers), input.response ?? ""];
   const approved = values.some(
@@ -16510,51 +16444,6 @@ function parseApprovalRequest(method, requestId, params) {
       return null;
   }
 }
-function toolProjection(input) {
-  if (input.phase === "started") {
-    return [
-      {
-        role: "assistant",
-        kind: "tool_call",
-        content: {
-          parts: [
-            {
-              type: "tool_call",
-              toolCallId: input.itemId,
-              name: input.name,
-              input: input.input
-            }
-          ]
-        }
-      }
-    ];
-  }
-  return [
-    {
-      role: "tool",
-      kind: "tool_result",
-      content: {
-        parts: [
-          {
-            type: "tool_result",
-            toolUseId: input.itemId,
-            output: input.output,
-            isError: input.isError
-          }
-        ]
-      }
-    }
-  ];
-}
-function textContent2(text) {
-  return { parts: [{ type: "text", text }] };
-}
-function reasoningContent(text) {
-  return { parts: [{ type: "reasoning", text }] };
-}
-function isFailedStatus(status) {
-  return status === "failed" || status === "declined";
-}
 var CodexRequestIdSchema, CodexTurnStatusSchema, CodexUserMessageItemSchema, CodexAgentMessageItemSchema, CodexReasoningItemSchema, CodexCommandExecutionItemSchema, CodexFileChangeItemSchema, CodexMcpToolCallItemSchema, CodexItemSchema, OptionalCodexItemSchema, CodexItemEnvelopeSchema, CodexTurnEnvelopeSchema, CodexTokenUsageSchema, CodexTokenUsageEnvelopeSchema, CodexFrameSchema, APPROVE_OPTION_LABEL, DECLINE_OPTION_LABEL;
 var init_codex = __esm({
   "../../packages/schemas/src/codex.ts"() {
@@ -16658,6 +16547,9 @@ var init_codex = __esm({
 
 // ../../packages/schemas/src/conversation-reducer.ts
 function reduceConversationRealtimeEvent(entries, event) {
+  if (event.type === "ui.message.chunk") {
+    return [...entries];
+  }
   if (event.type === "conversation.delta") {
     const existingIndex = entries.findIndex(
       (entry) => entry.messageId === event.messageId
@@ -18988,7 +18880,7 @@ function isSessionTerminalStatus(status) {
     (terminalStatus) => terminalStatus === status
   );
 }
-var SESSION_STATUSES, SESSION_RUNTIME_PHASES, SESSION_TERMINAL_STATUSES, SESSION_DISPLAY_TITLE_MAX_LENGTH, SessionStatusSchema, SessionRuntimePhaseSchema, RunDisplayTitleSchema, AmbientStatusSchema, SESSION_CHECK_STATUSES, SESSION_CHECK_CONCLUSIONS, SESSION_CHECK_TIMEOUT_PHASES, SessionCheckStatusSchema, SessionCheckConclusionSchema, SessionCheckTimeoutPhaseSchema, ManualSessionRequestSchema, SessionArchiveRequestSchema, SessionsArchiveRequestSchema, SessionRecordSchema, SessionListItemAgentSchema, SessionListItemSchema, SessionListResponseSchema, SessionsArchiveResponseSchema;
+var SESSION_STATUSES, SESSION_RUNTIME_PHASES, SESSION_TERMINAL_STATUSES, SESSION_DISPLAY_TITLE_MAX_LENGTH, SESSION_MESSAGE_ROLES, SESSION_MESSAGE_STATUSES, SessionStatusSchema, SessionRuntimePhaseSchema, SessionMessageRoleSchema, SessionMessageStatusSchema, RunDisplayTitleSchema, AmbientStatusSchema, SESSION_CHECK_STATUSES, SESSION_CHECK_CONCLUSIONS, SESSION_CHECK_TIMEOUT_PHASES, SessionCheckStatusSchema, SessionCheckConclusionSchema, SessionCheckTimeoutPhaseSchema, ManualSessionRequestSchema, SessionArchiveRequestSchema, SessionsArchiveRequestSchema, SessionRecordSchema, SessionUiMessageRecordSchema, SessionListItemAgentSchema, SessionListItemSchema, SessionListResponseSchema, SessionsArchiveResponseSchema;
 var init_sessions = __esm({
   "../../packages/schemas/src/sessions.ts"() {
     "use strict";
@@ -19015,8 +18907,16 @@ var init_sessions = __esm({
     ];
     SESSION_TERMINAL_STATUSES = ["failed", "stopped"];
     SESSION_DISPLAY_TITLE_MAX_LENGTH = 64;
+    SESSION_MESSAGE_ROLES = ["system", "user", "assistant"];
+    SESSION_MESSAGE_STATUSES = [
+      "in_progress",
+      "completed",
+      "failed"
+    ];
     SessionStatusSchema = external_exports.enum(SESSION_STATUSES);
     SessionRuntimePhaseSchema = external_exports.enum(SESSION_RUNTIME_PHASES);
+    SessionMessageRoleSchema = external_exports.enum(SESSION_MESSAGE_ROLES);
+    SessionMessageStatusSchema = external_exports.enum(SESSION_MESSAGE_STATUSES);
     RunDisplayTitleSchema = external_exports.string().trim().max(SESSION_DISPLAY_TITLE_MAX_LENGTH);
     AmbientStatusSchema = external_exports.string().trim().min(1);
     SESSION_CHECK_STATUSES = [
@@ -19054,6 +18954,12 @@ var init_sessions = __esm({
       correlationKey: external_exports.string().nullable(),
       workflowId: external_exports.string().min(1),
       displayTitle: RunDisplayTitleSchema,
+      // Default to null so session.upsert entity records emitted before/without the
+      // active-stream metadata validate (undefined -> null) instead of throwing;
+      // the output type stays `string | null`, so consumers are unaffected.
+      activeUiMessageStreamId: external_exports.string().trim().min(1).nullable().default(null),
+      activeUiMessageStreamCommandId: external_exports.string().trim().min(1).nullable().default(null),
+      activeUiMessageStreamStartedAt: external_exports.string().datetime().nullable().default(null),
       ambientStatus: AmbientStatusSchema.nullable(),
       ambientStatusUpdatedAt: external_exports.string().datetime().nullable(),
       starterActor: AuthActorSchema.nullable(),
@@ -19075,6 +18981,20 @@ var init_sessions = __esm({
       archivedAt: external_exports.string().datetime().nullable(),
       error: JsonValueSchema.nullable()
     });
+    SessionUiMessageRecordSchema = external_exports.object({
+      id: external_exports.string().trim().min(1),
+      sessionId: SessionIdSchema,
+      sequence: external_exports.number().int().nonnegative(),
+      messageId: external_exports.string().trim().min(1),
+      commandId: external_exports.string().trim().min(1).nullable(),
+      turnId: external_exports.string().trim().min(1).nullable(),
+      role: SessionMessageRoleSchema,
+      status: SessionMessageStatusSchema,
+      message: JsonValueSchema,
+      createdAt: external_exports.string().datetime(),
+      updatedAt: external_exports.string().datetime(),
+      completedAt: external_exports.string().datetime().nullable()
+    });
     SessionListItemAgentSchema = external_exports.object({
       name: external_exports.string(),
       displayName: external_exports.string().nullable(),
@@ -23220,7 +23140,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.282",
+      version: "0.1.283",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -23252,6 +23172,7 @@ var init_package = __esm({
         "@anthropic-ai/claude-agent-sdk": "^0.3.153",
         "@inkjs/ui": "^2.0.0",
         "@tanstack/react-query": "^5.100.14",
+        ai: "^6.0.217",
         chalk: "^5.3.0",
         commander: "^14.0.2",
         ink: "^7",
@@ -23860,6 +23781,9 @@ function createConversationStreamWriter(input) {
       input.writeLine(formatConversationRealtimeEvent(event));
       return;
     }
+    if (event.type === "ui.message.chunk") {
+      return;
+    }
     if (event.messageId && streamedMessageIds.has(event.messageId)) {
       streamedMessageIds.delete(event.messageId);
       input.writeChunk?.("\n");
@@ -23872,6 +23796,10 @@ function createConversationStreamWriter(input) {
   };
 }
 function formatConversationRealtimeEvent(event) {
+  if (event.type === "ui.message.chunk") {
+    const chunkType = typeof event.chunk === "object" && event.chunk !== null && !Array.isArray(event.chunk) && typeof event.chunk.type === "string" ? event.chunk.type : "unknown";
+    return `[${event.sequence}] ui message chunk: ${chunkType}`;
+  }
   if (event.type === "conversation.delta") {
     return `[${event.sequence}] assistant/message ${event.delta.type} delta: ${event.delta.text}`;
   }
@@ -23893,6 +23821,9 @@ function formatConversationEntry(entry) {
         (question) => `${question.question} [${question.options.map((option) => option.label).join(" | ")}]`
       ).join("; ");
     }
+    if (part.type === "ui_message") {
+      return JSON.stringify(part.message);
+    }
     return `${part.isError ? "tool error" : "tool result"} ${part.toolUseId ?? ""}: ${JSON.stringify(part.output)}`;
   }).join("");
   return `[${entry.sequence}] ${entry.role}/${entry.kind}: ${content}`;
@@ -27643,6 +27574,10 @@ function ConversationView({
         sawLiveTurnActivity.current = true;
         return;
       }
+      if (event.type === "ui.message.chunk") {
+        sawLiveTurnActivity.current = true;
+        return;
+      }
       if (event.kind === "question") {
         pendingLocalCommand.current = null;
         updateAwaitingReply(false);
@@ -28159,6 +28094,9 @@ function streamedCharCount(event) {
   if (event.type === "conversation.delta") {
     return event.delta.text.length;
   }
+  if (event.type !== "conversation.entry") {
+    return 0;
+  }
   if (event.kind === "tool_call" && event.status !== "in_progress") {
     return event.content.parts.filter((part) => part.type === "tool_call").reduce((total, part) => total + JSON.stringify(part.input).length, 0);
   }
@@ -32996,12 +32934,17 @@ var ConversationQuestionContentPartSchema2 = external_exports.object({
   toolCallId: external_exports.string().min(1).nullable(),
   questions: external_exports.array(ConversationQuestionSchema2)
 });
+var ConversationUiMessageContentPartSchema2 = external_exports.object({
+  type: external_exports.literal("ui_message"),
+  message: JsonValueSchema2
+});
 var ConversationContentPartSchema2 = external_exports.discriminatedUnion("type", [
   ConversationTextContentPartSchema2,
   ConversationReasoningContentPartSchema2,
   ConversationToolCallContentPartSchema2,
   ConversationToolResultContentPartSchema2,
-  ConversationQuestionContentPartSchema2
+  ConversationQuestionContentPartSchema2,
+  ConversationUiMessageContentPartSchema2
 ]);
 var ConversationEntryContentSchema2 = external_exports.object({
   parts: external_exports.array(ConversationContentPartSchema2)
@@ -33183,9 +33126,35 @@ var RuntimeBridgeOutputDeltaEnvelopeSchema = external_exports.object({
   delta: ConversationDeltaSchema2,
   createdAt: external_exports.string().datetime()
 }).strict();
+var RuntimeBridgeOutputUiMessageChunkEnvelopeSchema = external_exports.object({
+  type: external_exports.literal("ui.message.chunk"),
+  sessionId: SessionIdSchema2,
+  runtimeId: RuntimeIdSchema2,
+  bridgeLeaseId: RuntimeBridgeLeaseIdSchema2,
+  outputSeq: external_exports.number().int().positive(),
+  chunk: JsonValueSchema2,
+  createdAt: external_exports.string().datetime()
+}).strict();
+var RuntimeBridgeOutputUiMessageCompletedEnvelopeSchema = external_exports.object({
+  type: external_exports.literal("ui.message.completed"),
+  sessionId: SessionIdSchema2,
+  runtimeId: RuntimeIdSchema2,
+  bridgeLeaseId: RuntimeBridgeLeaseIdSchema2,
+  outputSeq: external_exports.number().int().positive(),
+  messageId: external_exports.string().trim().min(1),
+  role: external_exports.enum(["system", "user", "assistant"]),
+  status: ConversationEntryStatusSchema2,
+  message: JsonValueSchema2,
+  turnStatus: external_exports.enum(["waiting_for_input", "completed", "failed"]).optional(),
+  usage: RuntimeBridgeTurnUsageSchema.optional(),
+  createdAt: external_exports.string().datetime(),
+  completedAt: external_exports.string().datetime().nullable()
+}).strict();
 var RuntimeBridgeOutputEnvelopeSchema = external_exports.union([
   RuntimeBridgeOutputEntryEnvelopeSchema,
-  RuntimeBridgeOutputDeltaEnvelopeSchema
+  RuntimeBridgeOutputDeltaEnvelopeSchema,
+  RuntimeBridgeOutputUiMessageChunkEnvelopeSchema,
+  RuntimeBridgeOutputUiMessageCompletedEnvelopeSchema
 ]);
 function legacyRuntimeTurnStatus(entry, sessionStatusAfter) {
   if (sessionStatusAfter === "failed" || entry.status === "failed") {
@@ -33665,17 +33634,27 @@ function outputLogContext(output, socketId) {
     kind: "kind" in output ? output.kind : void 0,
     output_status: "status" in output ? output.status : void 0,
     delta_type: output.type === "conversation.delta" ? output.delta.type : void 0,
+    ui_chunk_type: output.type === "ui.message.chunk" ? jsonRecordString(output.chunk, "type") : void 0,
     message_id: "messageId" in output ? output.messageId : void 0
   };
 }
 function errorMessage(error51) {
   return error51 instanceof Error ? error51.message : String(error51);
 }
+function jsonRecordString(value, key) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
 
 // src/commands/agent-bridge/harness/claude-code/index.ts
 init_src();
 
 // src/commands/agent-bridge/harness/output-buffer.ts
+init_src();
+import { readUIMessageStream } from "ai";
 var AGENT_BRIDGE_OUTPUT_DELTA_FLUSH_MS = 50;
 var AgentBridgeOutputBuffer = class {
   constructor(input) {
@@ -33687,12 +33666,17 @@ var AgentBridgeOutputBuffer = class {
   pendingOutputs = /* @__PURE__ */ new Map();
   pendingDelta = null;
   deltaFlushTimer = null;
+  activeUiMessageAssembler = null;
   drainBlocked = false;
   drainPromise = null;
   // ---------------------------------------------------------------------------
   // Public API
   // ---------------------------------------------------------------------------
   async emitProjection(context, projection) {
+    if (projection.type === "ui_message_chunk") {
+      await this.emitUiMessageChunk(context, projection);
+      return;
+    }
     if (projection.type === "delta") {
       await this.bufferDelta(context, projection.delta);
       return;
@@ -33704,6 +33688,75 @@ var AgentBridgeOutputBuffer = class {
     await this.flushPendingDelta({ force: true });
     await this.drainPendingOutputs({ force: true });
   }
+  async emitUiMessageChunk(context, projection) {
+    if (projection.chunk.type === "data-auto-question") {
+      await this.flushPendingDelta();
+      await this.emitLiveUiMessageChunk(context, projection.chunk);
+      await this.enqueueProjectionAndDrain(context, {
+        type: "entry",
+        entry: {
+          role: "assistant",
+          kind: "question",
+          ...projection.turnStatus ? { turnStatus: projection.turnStatus } : {},
+          content: {
+            parts: [questionPart(projection.chunk.data)]
+          }
+        }
+      });
+      return;
+    }
+    await this.flushPendingDelta();
+    await this.emitLiveUiMessageChunk(context, projection.chunk);
+    const completedMessage = await this.appendUiChunkToAssembler(
+      projection.chunk
+    );
+    if (!completedMessage || !completedMessage.id.trim()) {
+      if (isTerminalUiMessageChunk(projection.chunk)) {
+        const statusText = terminalStatusText(projection);
+        if (statusText) {
+          await this.enqueueProjectionAndDrain(context, {
+            type: "entry",
+            entry: {
+              role: "system",
+              kind: "status",
+              status: terminalEntryStatus(projection),
+              ...projection.turnStatus ? { turnStatus: projection.turnStatus } : {},
+              ...projection.usage ? { usage: projection.usage } : {},
+              content: {
+                parts: [{ type: "text", text: statusText }]
+              }
+            }
+          });
+        }
+      }
+      return;
+    }
+    this.outputSeq += 1;
+    const completedAt = now2();
+    const completedOutput = buildUiMessageCompletedOutputEnvelope({
+      context,
+      outputSeq: this.outputSeq,
+      message: completedMessage,
+      status: terminalEntryStatus(projection),
+      turnStatus: projection.turnStatus,
+      usage: projection.usage,
+      createdAt: completedAt,
+      completedAt
+    });
+    this.enqueueOutput(completedOutput);
+    await this.drainPendingOutputs();
+  }
+  async emitLiveUiMessageChunk(context, chunk) {
+    this.outputSeq += 1;
+    const output = buildUiMessageChunkOutputEnvelope({
+      context,
+      outputSeq: this.outputSeq,
+      chunk,
+      createdAt: now2()
+    });
+    this.enqueueOutput(output);
+    await this.drainPendingOutputs();
+  }
   // ---------------------------------------------------------------------------
   // Transport emit
   // ---------------------------------------------------------------------------
@@ -33860,11 +33913,91 @@ var AgentBridgeOutputBuffer = class {
       kind: output && "kind" in output ? output.kind : void 0,
       output_status: output && "status" in output ? output.status : void 0,
       delta_type: output?.type === "conversation.delta" ? output.delta.type : void 0,
+      ui_chunk_type: output?.type === "ui.message.chunk" ? jsonRecordString2(output.chunk, "type") : void 0,
       message_id: output && "messageId" in output ? output.messageId : void 0,
       ...fields
     };
   }
+  async appendUiChunkToAssembler(chunk) {
+    if (chunk.type === "start" || !this.activeUiMessageAssembler || this.activeUiMessageAssembler.done) {
+      this.activeUiMessageAssembler = new UiMessageAssembler();
+    }
+    const completedMessage = await this.activeUiMessageAssembler.appendChunk(chunk);
+    if (completedMessage) {
+      this.activeUiMessageAssembler = null;
+    }
+    return completedMessage;
+  }
 };
+var UiMessageAssembler = class {
+  controller = null;
+  latestMessage = null;
+  closed = false;
+  drained;
+  constructor() {
+    const stream = new ReadableStream({
+      start: (controller) => {
+        this.controller = controller;
+      }
+    });
+    this.drained = (async () => {
+      try {
+        for await (const message of readUIMessageStream({
+          stream,
+          terminateOnError: false
+        })) {
+          this.latestMessage = message;
+        }
+      } finally {
+        this.closed = true;
+      }
+    })();
+  }
+  get done() {
+    return this.closed;
+  }
+  async appendChunk(chunk) {
+    try {
+      this.controller?.enqueue(chunk);
+    } catch {
+      this.closed = true;
+      return null;
+    }
+    if (!isTerminalUiMessageChunk(chunk)) {
+      return null;
+    }
+    this.closed = true;
+    this.controller?.close();
+    await this.drained;
+    return this.latestMessage;
+  }
+};
+function isTerminalUiMessageChunk(chunk) {
+  return chunk.type === "finish" || chunk.type === "error" || chunk.type === "abort";
+}
+function questionPart(data) {
+  const parsed = data;
+  return {
+    type: "question",
+    toolCallId: parsed.toolCallId ?? null,
+    questions: parsed.questions
+  };
+}
+function terminalStatusText(projection) {
+  if (projection.statusText) {
+    return projection.statusText;
+  }
+  if (projection.chunk.type === "error") {
+    return projection.chunk.errorText;
+  }
+  return null;
+}
+function terminalEntryStatus(projection) {
+  if (projection.turnStatus === "failed" || projection.chunk.type === "error" || projection.chunk.type === "abort") {
+    return "failed";
+  }
+  return "completed";
+}
 function canCoalesceDelta(pending, context, delta) {
   return pending.context.sessionId === context.sessionId && pending.context.runtimeId === context.runtimeId && pending.context.bridgeLeaseId === context.bridgeLeaseId && pending.delta.messageId === delta.messageId && pending.delta.partId === delta.partId && pending.delta.role === delta.role && pending.delta.kind === delta.kind && pending.delta.delta.type === delta.delta.type;
 }
@@ -33924,67 +34057,209 @@ function buildDeltaOutputEnvelope(input) {
     createdAt: input.createdAt
   });
 }
+function buildUiMessageChunkOutputEnvelope(input) {
+  const { context } = input;
+  return RuntimeBridgeOutputEnvelopeSchema.parse({
+    type: "ui.message.chunk",
+    sessionId: context.sessionId,
+    runtimeId: context.runtimeId,
+    bridgeLeaseId: context.bridgeLeaseId,
+    outputSeq: input.outputSeq,
+    chunk: toJsonValue(input.chunk),
+    createdAt: input.createdAt
+  });
+}
+function buildUiMessageCompletedOutputEnvelope(input) {
+  const { context } = input;
+  return RuntimeBridgeOutputEnvelopeSchema.parse({
+    type: "ui.message.completed",
+    sessionId: context.sessionId,
+    runtimeId: context.runtimeId,
+    bridgeLeaseId: context.bridgeLeaseId,
+    outputSeq: input.outputSeq,
+    messageId: input.message.id,
+    role: input.message.role,
+    status: input.status,
+    message: toJsonValue(input.message),
+    ...input.turnStatus ? { turnStatus: input.turnStatus } : {},
+    ...input.usage ? { usage: input.usage } : {},
+    createdAt: input.createdAt,
+    completedAt: input.completedAt
+  });
+}
 function isSuccessfulOutputAck(ack) {
   return ack.status === "persisted" || ack.status === "duplicate" || ack.status === "published";
 }
 function now2() {
   return (/* @__PURE__ */ new Date()).toISOString();
 }
+function jsonRecordString2(value, key) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  const field = value[key];
+  return typeof field === "string" ? field : void 0;
+}
 
 // src/commands/agent-bridge/harness/claude-code/projector.ts
 init_src();
 var ClaudeCodeProjector = class {
   currentMessageId = null;
+  // The turn's UI message id. Claude emits a `message_start` per assistant
+  // message, but a tool-using turn spans several (message A with the tool call,
+  // the tool result, then message B). We open the UI message once per turn and
+  // bracket each message as a step (finish-step at message_stop), closing it
+  // with the single terminal `finish` at the turn result — so the whole turn,
+  // including paired tool input/output, assembles into one UIMessage. Mirrors
+  // the Codex projector's `ensureResponseStarted`.
+  activeResponseMessageId = null;
+  activeParts = /* @__PURE__ */ new Map();
+  activeToolInputs = /* @__PURE__ */ new Map();
+  streamedMessageIds = /* @__PURE__ */ new Set();
   project(message) {
     if (message.type === "stream_event") {
-      if (message.event.type === "message_start") {
-        this.currentMessageId = anthropicMessageIdFromStreamStart(message) ?? UNKNOWN_MESSAGE_ID;
-        return [];
-      }
-      if (message.event.type === "message_stop") {
-        this.currentMessageId = null;
-        return [];
-      }
-      const delta = partialAssistantDeltaPayload(
-        message,
-        this.currentMessageId ?? UNKNOWN_MESSAGE_ID
-      );
-      return delta ? [{ type: "delta", delta }] : [];
+      return this.projectStreamEvent(message);
     }
     const parsed = parseClaudeCodeStreamRecord(message);
-    const outputs = parsed.projections.map(
-      (entry) => ({
-        type: "entry",
-        // A question means the delivered turn is parked on AskUserQuestion
-        // waiting for an operator answer.
-        entry: entry.kind === "question" ? { ...entry, turnStatus: "waiting_for_input" } : entry
-      })
-    );
+    const snapshotMessageId = assistantSnapshotMessageId(message);
+    const suppressStreamed = snapshotMessageId !== null && this.streamedMessageIds.has(snapshotMessageId);
+    const outputs = !suppressStreamed && message.type === "assistant" ? projectAssistantSnapshot(parsed.projections) : parsed.projections.flatMap((entry) => {
+      if (suppressStreamed && (entry.kind === "message" || entry.kind === "tool_call")) {
+        return [];
+      }
+      return conversationProjectionToUiChunks(entry);
+    });
     if (parsed.result) {
+      outputs.push(...this.endActiveParts(), ...this.finishActiveToolInputs());
+      this.currentMessageId = null;
+      this.activeResponseMessageId = null;
       outputs.push(projectClaudeCodeResult(parsed.result));
     }
     return outputs;
   }
+  flushPendingAssistantMessages() {
+    const outputs = [
+      ...this.endActiveParts(),
+      uiChunk({ type: "finish", finishReason: "stop" })
+    ];
+    this.currentMessageId = null;
+    this.activeResponseMessageId = null;
+    return outputs;
+  }
+  projectStreamEvent(message) {
+    if (message.event.type === "message_start") {
+      this.currentMessageId = anthropicMessageIdFromStreamStart(message) ?? UNKNOWN_MESSAGE_ID;
+      this.streamedMessageIds.add(this.currentMessageId);
+      this.activeParts.clear();
+      this.activeToolInputs.clear();
+      return this.ensureResponseStarted(this.currentMessageId);
+    }
+    if (message.event.type === "message_stop") {
+      const outputs = [
+        ...this.endActiveParts(),
+        ...this.finishActiveToolInputs(),
+        uiChunk({ type: "finish-step" })
+      ];
+      this.currentMessageId = null;
+      return outputs;
+    }
+    if (message.event.type === "content_block_start") {
+      return this.startToolInput(message);
+    }
+    if (message.event.type === "content_block_stop") {
+      return [
+        ...this.endActivePart(blockIndexId(message.event.index)),
+        ...this.finishActiveToolInput(blockIndexId(message.event.index))
+      ];
+    }
+    return partialAssistantDeltaProjections(
+      message,
+      this.activeParts,
+      this.activeToolInputs
+    );
+  }
+  // Open the turn's UI message exactly once. Subsequent messages in the same
+  // turn reuse it (their content becomes additional steps), so the turn
+  // assembles into a single UIMessage instead of the assembler resetting on
+  // each `start` and dropping every message but the last.
+  ensureResponseStarted(messageId) {
+    if (this.activeResponseMessageId !== null) {
+      return [];
+    }
+    this.activeResponseMessageId = messageId;
+    return [uiChunk({ type: "start", messageId })];
+  }
+  endActiveParts() {
+    const outputs = [...this.activeParts].map(([id]) => this.endActivePart(id));
+    this.activeParts.clear();
+    return outputs.flat();
+  }
+  endActivePart(id) {
+    const type = this.activeParts.get(id);
+    if (!type) {
+      return [];
+    }
+    this.activeParts.delete(id);
+    return [uiChunk({ type: `${type}-end`, id })];
+  }
+  startToolInput(message) {
+    const started = toolInputStartFromEvent(message);
+    if (!started) {
+      return [];
+    }
+    this.activeToolInputs.set(started.index, {
+      toolCallId: started.toolCallId,
+      toolName: started.toolName,
+      initialInput: started.input,
+      inputText: ""
+    });
+    return [
+      uiChunk({
+        type: "tool-input-start",
+        toolCallId: started.toolCallId,
+        toolName: started.toolName
+      })
+    ];
+  }
+  finishActiveToolInput(index) {
+    const active = this.activeToolInputs.get(index);
+    if (!active) {
+      return [];
+    }
+    this.activeToolInputs.delete(index);
+    return [
+      uiChunk({
+        type: "tool-input-available",
+        toolCallId: active.toolCallId,
+        toolName: active.toolName,
+        input: completeToolInput(active)
+      })
+    ];
+  }
+  finishActiveToolInputs() {
+    return [...this.activeToolInputs.keys()].flatMap(
+      (index) => this.finishActiveToolInput(index)
+    );
+  }
 };
 function projectClaudeCodeResult(result) {
   return {
-    type: "entry",
-    entry: {
-      role: "system",
-      kind: "status",
-      status: result.isError ? "failed" : "completed",
-      turnStatus: result.isError ? "failed" : "completed",
-      content: {
-        parts: [
-          {
-            type: "text",
-            text: result.isError ? `claude-code failed: ${result.errorMessage ?? "unknown error"}` : "claude-code completed"
-          }
-        ]
-      }
-    }
+    type: "ui_message_chunk",
+    chunk: {
+      type: "finish",
+      finishReason: result.isError ? "error" : "stop"
+    },
+    statusText: result.isError ? `claude-code failed: ${result.errorMessage ?? "unknown error"}` : "claude-code completed",
+    turnStatus: result.isError ? "failed" : "completed"
   };
 }
+function assistantSnapshotMessageId(message) {
+  if (message.type !== "assistant") {
+    return null;
+  }
+  const id = message.message.id;
+  return typeof id === "string" && id.trim() ? id : UNKNOWN_MESSAGE_ID;
+}
 function anthropicMessageIdFromStreamStart(message) {
   const event = message.event;
   if (event.type !== "message_start") {
@@ -33993,27 +34268,284 @@ function anthropicMessageIdFromStreamStart(message) {
   const id = event.message.id;
   return typeof id === "string" && id.trim() ? id : null;
 }
-function partialAssistantDeltaPayload(message, messageId) {
+function partialAssistantDeltaProjections(message, activeParts, activeToolInputs) {
   const event = message.event;
   if (event.type !== "content_block_delta") {
-    return null;
+    return [];
+  }
+  const toolInputDelta = toolInputDeltaFromDelta(event.delta);
+  if (toolInputDelta) {
+    const active = activeToolInputs.get(blockIndexId(event.index));
+    if (!active) {
+      return [];
+    }
+    active.inputText += toolInputDelta;
+    return [
+      uiChunk({
+        type: "tool-input-delta",
+        toolCallId: active.toolCallId,
+        inputTextDelta: toolInputDelta
+      })
+    ];
+  }
+  const sourceChunk = sourceChunkFromDelta(event.delta, event.index);
+  if (sourceChunk) {
+    return [uiChunk(sourceChunk)];
   }
   const delta = event.delta;
-  const text = delta.type === "text_delta" ? delta.text : delta.type === "thinking_delta" ? delta.thinking : "";
-  if (text.length === 0) {
+  const content = textContentFromDelta(delta);
+  if (!content || content.text.length === 0) {
+    return [];
+  }
+  const id = typeof event.index === "number" ? String(event.index) : "0";
+  const outputs = [];
+  if (!activeParts.has(id)) {
+    activeParts.set(id, content.type);
+    outputs.push(
+      uiChunk({ type: `${content.type}-start`, id })
+    );
+  }
+  outputs.push(
+    uiChunk({
+      type: `${content.type}-delta`,
+      id,
+      delta: content.text
+    })
+  );
+  return outputs;
+}
+function toolInputStartFromEvent(message) {
+  const event = message.event;
+  if (event.type !== "content_block_start") {
+    return null;
+  }
+  const contentBlock = event.content_block;
+  if (contentBlock.type !== "tool_use" && contentBlock.type !== "mcp_tool_use" && contentBlock.type !== "server_tool_use") {
+    return null;
+  }
+  const id = contentBlock.id;
+  const name = contentBlock.name;
+  if (typeof id !== "string" || typeof name !== "string") {
+    return null;
+  }
+  if (name === ASK_USER_QUESTION_TOOL_NAME) {
     return null;
   }
-  const index = event.index;
-  const type = delta.type === "thinking_delta" ? "reasoning" : "text";
   return {
-    messageId,
-    partId: typeof index === "number" ? String(index) : "0",
-    role: "assistant",
-    kind: "message",
-    delta: {
-      type,
-      text
+    index: blockIndexId(event.index),
+    toolCallId: id,
+    toolName: toolNameFromContentBlock(contentBlock, name),
+    input: contentBlock.input
+  };
+}
+function toolInputDeltaFromDelta(delta) {
+  if (delta.type !== "input_json_delta") {
+    return null;
+  }
+  return delta.partial_json;
+}
+function completeToolInput(input) {
+  const inputText = input.inputText.trim();
+  if (inputText.length > 0) {
+    try {
+      return JSON.parse(inputText);
+    } catch {
+      return input.inputText;
+    }
+  }
+  return input.initialInput ?? {};
+}
+function sourceChunkFromDelta(delta, index) {
+  if (delta.type !== "citations_delta") {
+    return null;
+  }
+  const citation = delta.citation;
+  if (citation.type === "web_search_result_location" && typeof citation.url === "string") {
+    return {
+      type: "source-url",
+      sourceId: citationSourceId(citation, index),
+      url: citation.url,
+      ...typeof citation.title === "string" ? { title: citation.title } : {},
+      providerMetadata: anthropicCitationMetadata(citation)
+    };
+  }
+  return {
+    type: "source-document",
+    sourceId: citationSourceId(citation, index),
+    mediaType: "text/plain",
+    title: citationTitle(citation, index),
+    providerMetadata: anthropicCitationMetadata(citation)
+  };
+}
+function toolNameFromContentBlock(contentBlock, name) {
+  return contentBlock.type === "mcp_tool_use" && typeof contentBlock.server_name === "string" ? `${contentBlock.server_name}.${name}` : name;
+}
+function citationSourceId(citation, index) {
+  for (const key of ["encrypted_index", "file_id", "source"]) {
+    const value = citation[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  if (typeof citation.document_index === "number") {
+    return `document:${citation.document_index.toString()}`;
+  }
+  return `citation:${index.toString()}`;
+}
+function citationTitle(citation, index) {
+  for (const key of ["title", "document_title", "source", "file_id"]) {
+    const value = citation[key];
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value;
+    }
+  }
+  return `Claude citation ${index.toString()}`;
+}
+function anthropicCitationMetadata(citation) {
+  return { anthropic: { citation: toJsonValue(citation) } };
+}
+function blockIndexId(index) {
+  return index.toString();
+}
+function textContentFromDelta(delta) {
+  switch (delta.type) {
+    case "text_delta":
+      return { type: "text", text: delta.text };
+    case "thinking_delta":
+      return { type: "reasoning", text: delta.thinking };
+    default:
+      return null;
+  }
+}
+function conversationProjectionToUiChunks(projection) {
+  if (projection.role === "assistant" && projection.kind === "message") {
+    return messageContentChunks(projection);
+  }
+  if (projection.kind === "tool_call") {
+    return toolCallChunks(projection);
+  }
+  if (projection.kind === "tool_result") {
+    return projection.content.parts.flatMap((part) => {
+      if (part.type !== "tool_result") {
+        return [];
+      }
+      return [
+        uiChunk(
+          part.isError ? {
+            type: "tool-output-error",
+            toolCallId: part.toolUseId ?? UNKNOWN_MESSAGE_ID,
+            errorText: JSON.stringify(part.output)
+          } : {
+            type: "tool-output-available",
+            toolCallId: part.toolUseId ?? UNKNOWN_MESSAGE_ID,
+            output: part.output
+          }
+        )
+      ];
+    });
+  }
+  if (projection.kind === "question") {
+    return projection.content.parts.flatMap(
+      (part) => part.type === "question" ? [
+        {
+          type: "ui_message_chunk",
+          chunk: {
+            type: "data-auto-question",
+            data: {
+              toolCallId: part.toolCallId,
+              questions: part.questions
+            }
+          },
+          turnStatus: "waiting_for_input"
+        }
+      ] : []
+    );
+  }
+  return [
+    {
+      type: "entry",
+      entry: projection
+    }
+  ];
+}
+function projectAssistantSnapshot(projections) {
+  return [
+    ...assistantSnapshotMessageChunks(projections),
+    ...projections.filter((projection) => !isAssistantMessageOrToolCall(projection)).flatMap((projection) => conversationProjectionToUiChunks(projection))
+  ];
+}
+function assistantSnapshotMessageChunks(projections) {
+  const messageProjection = projections.find(
+    (projection) => projection.role === "assistant" && projection.kind === "message"
+  );
+  const toolCallProjections = projections.filter(
+    (projection) => projection.role === "assistant" && projection.kind === "tool_call"
+  );
+  if (!messageProjection && toolCallProjections.length === 0) {
+    return [];
+  }
+  const messageId = messageProjection?.messageId ?? toolCallProjections.find((projection) => projection.messageId)?.messageId ?? UNKNOWN_MESSAGE_ID;
+  const outputs = [
+    uiChunk({ type: "start", messageId })
+  ];
+  if (messageProjection) {
+    outputs.push(...messagePartChunks(messageProjection));
+  }
+  outputs.push(
+    ...toolCallProjections.flatMap((projection) => toolCallChunks(projection))
+  );
+  if (toolCallProjections.length === 0) {
+    outputs.push(uiChunk({ type: "finish", finishReason: "stop" }));
+  }
+  return outputs;
+}
+function isAssistantMessageOrToolCall(projection) {
+  return projection.role === "assistant" && (projection.kind === "message" || projection.kind === "tool_call");
+}
+function messageContentChunks(projection) {
+  const messageId = projection.messageId ?? UNKNOWN_MESSAGE_ID;
+  const outputs = [
+    uiChunk({ type: "start", messageId })
+  ];
+  outputs.push(...messagePartChunks(projection));
+  outputs.push(uiChunk({ type: "finish", finishReason: "stop" }));
+  return outputs;
+}
+function messagePartChunks(projection) {
+  const outputs = [];
+  for (const [index, part] of projection.content.parts.entries()) {
+    if (part.type !== "text" && part.type !== "reasoning") {
+      continue;
     }
+    const id = `${part.type}-${index.toString()}`;
+    outputs.push(
+      uiChunk({ type: `${part.type}-start`, id }),
+      uiChunk({
+        type: `${part.type}-delta`,
+        id,
+        delta: part.text
+      }),
+      uiChunk({ type: `${part.type}-end`, id })
+    );
+  }
+  return outputs;
+}
+function toolCallChunks(projection) {
+  return projection.content.parts.flatMap(
+    (part) => part.type === "tool_call" ? [
+      uiChunk({
+        type: "tool-input-available",
+        toolCallId: part.toolCallId ?? UNKNOWN_MESSAGE_ID,
+        toolName: part.name,
+        input: part.input
+      })
+    ] : []
+  );
+}
+function uiChunk(chunk) {
+  return {
+    type: "ui_message_chunk",
+    chunk
   };
 }
 
@@ -35264,6 +35796,9 @@ var ClaudeCodeCommandHandler = class {
     if (!activeContext) {
       return;
     }
+    for (const projection of this.projector.flushPendingAssistantMessages()) {
+      await this.emitBridgeOutput(activeContext, projection);
+    }
     await this.emitBridgeOutput(
       activeContext,
       projectClaudeCodeResult({
@@ -35377,30 +35912,27 @@ init_src();
 // src/commands/agent-bridge/harness/codex/projector.ts
 init_src();
 var CodexProjector = class {
+  activeAgentMessages = /* @__PURE__ */ new Set();
+  activeToolCalls = /* @__PURE__ */ new Set();
+  activeResponseMessageId = null;
   project(notification) {
     switch (notification.type) {
       case "agentMessageDelta":
         return [
-          {
-            type: "delta",
-            delta: {
-              messageId: notification.itemId,
-              partId: "0",
-              role: "assistant",
-              kind: "message",
-              delta: { type: "text", text: notification.delta }
-            }
-          }
+          ...this.ensureResponseStarted(notification.itemId),
+          ...this.projectAgentMessageDelta(
+            notification.itemId,
+            notification.delta
+          )
         ];
       case "itemStarted":
-        return entryProjections(
-          projectCodexItem({ item: notification.item, phase: "started" })
-        );
+        return this.projectItem(notification.item, "started");
       case "itemCompleted":
-        return entryProjections(
-          projectCodexItem({ item: notification.item, phase: "completed" })
-        );
+        return this.projectItem(notification.item, "completed");
       case "turnCompleted":
+        this.activeResponseMessageId = null;
+        this.activeAgentMessages.clear();
+        this.activeToolCalls.clear();
         return [turnCompletionEntry(notification)];
       case "error":
         return [errorEntry(notification)];
@@ -35408,81 +35940,267 @@ var CodexProjector = class {
         return [];
     }
   }
-  // An approval parks the turn on operator input, so the question entry also
+  // An approval parks the turn on operator input, so the question chunk also
   // marks the delivered turn as waiting for input.
   projectApproval(request) {
-    return {
-      type: "entry",
-      entry: {
-        ...projectCodexApproval(request),
+    return [
+      uiChunk2({
+        type: "tool-approval-request",
+        approvalId: String(request.requestId),
+        toolCallId: request.itemId
+      }),
+      {
+        type: "ui_message_chunk",
+        chunk: {
+          type: "data-auto-question",
+          data: {
+            toolCallId: request.itemId,
+            questions: [approvalQuestion(request)]
+          }
+        },
         turnStatus: "waiting_for_input"
       }
-    };
+    ];
   }
   // Surfaces a session-level failure (e.g. the app-server process dying) as a
   // durable failed status entry rather than only a diagnostic log line.
   projectSessionFailure(message) {
     return {
-      type: "entry",
-      entry: {
-        role: "system",
-        kind: "status",
-        status: "failed",
-        turnStatus: "failed",
-        content: {
-          parts: [{ type: "text", text: `codex failed: ${message}` }]
-        }
-      }
+      type: "ui_message_chunk",
+      chunk: { type: "error", errorText: `codex failed: ${message}` }
     };
   }
+  projectAgentMessageDelta(itemId, delta) {
+    const outputs = [];
+    if (!this.activeAgentMessages.has(itemId)) {
+      this.activeAgentMessages.add(itemId);
+      outputs.push(uiChunk2({ type: "text-start", id: textPartId(itemId) }));
+    }
+    outputs.push(
+      uiChunk2({ type: "text-delta", id: textPartId(itemId), delta })
+    );
+    return outputs;
+  }
+  projectItem(item, phase) {
+    switch (item.type) {
+      case "agentMessage":
+        return [
+          ...this.ensureResponseStarted(item.id),
+          ...this.projectAgentMessageItem(item, phase)
+        ];
+      case "reasoning":
+        return phase === "completed" ? [
+          ...this.ensureResponseStarted(item.id),
+          ...reasoningItemChunks(item)
+        ] : [];
+      case "commandExecution":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: "shell",
+          input: {
+            command: item.command,
+            ...item.cwd ? { cwd: item.cwd } : {}
+          },
+          output: item.aggregatedOutput ?? "",
+          isError: isFailedStatus(item.status) || (item.exitCode ?? 0) !== 0,
+          title: item.command,
+          toolMetadata: statusMetadata(item.status, {
+            ...item.exitCode !== void 0 ? { exitCode: item.exitCode } : {}
+          })
+        });
+      case "fileChange":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: "apply_patch",
+          input: { changes: toJsonValue(item.changes) },
+          output: { status: item.status ?? "unknown" },
+          isError: isFailedStatus(item.status),
+          title: "apply_patch",
+          toolMetadata: statusMetadata(item.status)
+        });
+      case "mcpToolCall":
+        return this.projectToolItem({
+          phase,
+          itemId: item.id,
+          name: `${item.server}.${item.tool}`,
+          input: toJsonValue(item.arguments),
+          output: item.error ? { error: item.error.message } : toJsonValue(item.result),
+          isError: isFailedStatus(item.status) || item.error != null,
+          title: `${item.server}.${item.tool}`,
+          toolMetadata: statusMetadata(item.status, {
+            server: item.server,
+            tool: item.tool
+          })
+        });
+      default:
+        return [];
+    }
+  }
+  projectToolItem(input) {
+    const outputs = [];
+    outputs.push(...this.ensureResponseStarted(input.itemId));
+    if (input.phase === "started" || !this.activeToolCalls.has(input.itemId)) {
+      outputs.push(toolInputChunk(input));
+      this.activeToolCalls.add(input.itemId);
+    }
+    if (input.phase === "started") {
+      return outputs;
+    }
+    outputs.push(toolOutputChunk(input));
+    outputs.push(uiChunk2({ type: "finish-step" }));
+    this.activeToolCalls.delete(input.itemId);
+    return outputs;
+  }
+  projectAgentMessageItem(item, phase) {
+    if (phase === "started") {
+      if (this.activeAgentMessages.has(item.id)) {
+        return [];
+      }
+      this.activeAgentMessages.add(item.id);
+      return [uiChunk2({ type: "text-start", id: textPartId(item.id) })];
+    }
+    const outputs = [];
+    if (!this.activeAgentMessages.has(item.id)) {
+      outputs.push(uiChunk2({ type: "text-start", id: textPartId(item.id) }));
+      if (item.text.length > 0) {
+        outputs.push(
+          uiChunk2({
+            type: "text-delta",
+            id: textPartId(item.id),
+            delta: item.text
+          })
+        );
+      }
+    }
+    outputs.push(
+      uiChunk2({ type: "text-end", id: textPartId(item.id) }),
+      uiChunk2({ type: "finish-step" })
+    );
+    this.activeAgentMessages.delete(item.id);
+    return outputs;
+  }
+  ensureResponseStarted(messageId) {
+    if (this.activeResponseMessageId !== null) {
+      return [];
+    }
+    this.activeResponseMessageId = messageId;
+    return [uiChunk2({ type: "start", messageId })];
+  }
 };
-function entryProjections(projections) {
-  return projections.map((projection) => ({
-    type: "entry",
-    entry: projection
-  }));
+function reasoningItemChunks(item) {
+  const text = item.summary.map((line) => line.trim()).filter(Boolean).join("\n\n");
+  if (text.length === 0) {
+    return [];
+  }
+  const id = reasoningPartId(item.id);
+  return [
+    uiChunk2({ type: "reasoning-start", id }),
+    uiChunk2({ type: "reasoning-delta", id, delta: text }),
+    uiChunk2({ type: "reasoning-end", id }),
+    uiChunk2({ type: "finish-step" })
+  ];
+}
+function toolInputChunk(input) {
+  return uiChunk2({
+    type: "tool-input-available",
+    toolCallId: input.itemId,
+    toolName: input.name,
+    input: input.input,
+    ...input.title ? { title: input.title } : {},
+    ...input.toolMetadata ? { toolMetadata: input.toolMetadata } : {}
+  });
+}
+function toolOutputChunk(input) {
+  return uiChunk2(
+    input.isError ? {
+      type: "tool-output-error",
+      toolCallId: input.itemId,
+      errorText: JSON.stringify(input.output),
+      ...input.toolMetadata ? { toolMetadata: input.toolMetadata } : {}
+    } : {
+      type: "tool-output-available",
+      toolCallId: input.itemId,
+      output: input.output,
+      ...input.toolMetadata ? { toolMetadata: input.toolMetadata } : {}
+    }
+  );
 }
 function turnCompletionEntry(notification) {
   if (notification.status === "failed") {
     const detail = notification.errorMessage ?? "unknown error";
-    return statusEntry({
+    return statusFinish({
       text: `codex turn failed: ${detail}`,
-      status: "failed",
       turnStatus: "failed"
     });
   }
-  const text = notification.status === "interrupted" ? "codex turn interrupted" : "codex turn completed";
-  return statusEntry({
-    text,
-    status: "completed",
+  return statusFinish({
+    text: notification.status === "interrupted" ? "codex turn interrupted" : "codex turn completed",
     turnStatus: "completed"
   });
 }
 function errorEntry(notification) {
   if (notification.willRetry) {
-    return statusEntry({
-      text: `codex retrying after error: ${notification.message}`,
-      status: "completed"
+    return statusFinish({
+      text: `codex retrying after error: ${notification.message}`
     });
   }
-  return statusEntry({
+  return statusFinish({
     text: `codex error: ${notification.message}`,
-    status: "failed",
     turnStatus: "failed"
   });
 }
-function statusEntry(input) {
+function statusFinish(input) {
   return {
-    type: "entry",
-    entry: {
-      role: "system",
-      kind: "status",
-      status: input.status,
-      ...input.turnStatus ? { turnStatus: input.turnStatus } : {},
-      content: { parts: [{ type: "text", text: input.text }] }
-    }
+    type: "ui_message_chunk",
+    chunk: {
+      type: "finish",
+      finishReason: input.turnStatus === "failed" ? "error" : "stop"
+    },
+    statusText: input.text,
+    ...input.turnStatus ? { turnStatus: input.turnStatus } : {}
   };
 }
+function approvalQuestion(request) {
+  const subject = request.type === "commandExecution" ? `run the command: ${request.command ?? "(unknown command)"}` : "apply file changes";
+  return {
+    question: request.reason ? `Codex requests approval to ${subject}. ${request.reason}` : `Codex requests approval to ${subject}.`,
+    header: "Approval",
+    options: [
+      { label: APPROVE_OPTION_LABEL, description: "Allow this action." },
+      { label: DECLINE_OPTION_LABEL, description: "Reject this action." }
+    ],
+    multiSelect: false
+  };
+}
+function textPartId(itemId) {
+  return `${itemId}:text`;
+}
+function reasoningPartId(itemId) {
+  return `${itemId}:reasoning`;
+}
+function isFailedStatus(status) {
+  return status === "failed" || status === "declined";
+}
+function statusMetadata(status, fields = {}) {
+  return {
+    status: status ?? "unknown",
+    ...fields
+  };
+}
+function uiChunk2(chunk) {
+  return {
+    type: "ui_message_chunk",
+    chunk: normalizeChunk(chunk)
+  };
+}
+function normalizeChunk(chunk) {
+  if ("toolCallId" in chunk && (!chunk.toolCallId || chunk.toolCallId.trim().length === 0)) {
+    return { ...chunk, toolCallId: UNKNOWN_MESSAGE_ID };
+  }
+  return chunk;
+}
 
 // src/commands/agent-bridge/harness/codex/resume-store.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
@@ -36253,7 +36971,9 @@ var CodexCommandHandler = class {
     this.input.writeOutput?.(
       `agent_bridge_codex_question_pending tool_use_id=${request.itemId}`
     );
-    await this.emit(activeContext, this.projector.projectApproval(request));
+    for (const projection of this.projector.projectApproval(request)) {
+      await this.emit(activeContext, projection);
+    }
   }
   async handleSessionError(error51) {
     this.input.writeOutput?.(
@@ -40261,6 +40981,8 @@ function entryPreview(event, full) {
         return stringify5(part.output);
       case "question":
         return part.questions.map((question) => question.question).join(" ");
+      case "ui_message":
+        return stringify5(part.message);
       default:
         return "";
     }