webmux 0.35.0 → 0.37.0

package/backend/dist/server.js

@@ -1,13 +1,17 @@
 // @bun
 var __defProp = Object.defineProperty;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __require = import.meta.require;
@@ -6961,7 +6965,7 @@ import { networkInterfaces } from "os";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.35.0",
+  version: "0.37.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -10990,7 +10994,7 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// node_modules/.bun/@ts-rest+core@3.52.1+c185e43edea803d3/node_modules/@ts-rest/core/index.esm.mjs
+// node_modules/.bun/@ts-rest+core@3.52.1+0e383980587f1470/node_modules/@ts-rest/core/index.esm.mjs
 var isZodObjectStrict = (obj) => {
   return typeof (obj === null || obj === undefined ? undefined : obj.passthrough) === "function";
 };
@@ -11388,17 +11392,24 @@ var AgentsUiWorktreeSummarySchema = exports_external.object({
   conversation: WorktreeConversationRefSchema.nullable()
 });
 var AgentsUiConversationMessageRoleSchema = exports_external.enum(["user", "assistant"]);
-var AgentsUiConversationMessageStatusSchema = exports_external.enum(["completed", "inProgress"]);
-var AgentsUiConversationMessageKindSchema = exports_external.enum(["text", "toolUse", "toolResult"]);
+var AgentsUiConversationMessageStatusSchema = exports_external.enum(["completed", "inProgress", "failed"]);
+var AgentsUiConversationMessageKindSchema = exports_external.enum(["text", "thinking", "toolUse", "toolResult"]);
 var AgentsUiConversationMessageSchema = exports_external.object({
   id: exports_external.string(),
   turnId: exports_external.string(),
+  order: exports_external.number().int().nonnegative(),
   role: AgentsUiConversationMessageRoleSchema,
   text: exports_external.string(),
   status: AgentsUiConversationMessageStatusSchema,
   createdAt: exports_external.string().nullable(),
-  kind: AgentsUiConversationMessageKindSchema.optional(),
-  toolName: exports_external.string().optional()
+  kind: AgentsUiConversationMessageKindSchema,
+  phase: exports_external.string().optional(),
+  toolName: exports_external.string().optional(),
+  toolCallId: exports_external.string().optional(),
+  command: exports_external.string().optional(),
+  cwd: exports_external.string().optional(),
+  exitCode: exports_external.number().nullable().optional(),
+  durationMs: exports_external.number().nullable().optional()
 });
 var AgentsUiConversationStateSchema = exports_external.object({
   provider: WorktreeConversationProviderSchema,
@@ -11422,24 +11433,36 @@ var AgentsUiInterruptResponseSchema = exports_external.object({
   turnId: exports_external.string(),
   interrupted: exports_external.literal(true)
 });
-var AgentsUiConversationSnapshotEventSchema = exports_external.object({
-  type: exports_external.literal("snapshot"),
-  data: AgentsUiWorktreeConversationResponseSchema
-});
 var AgentsUiConversationMessageDeltaEventSchema = exports_external.object({
   type: exports_external.literal("messageDelta"),
+  revision: exports_external.number().int().nonnegative(),
   conversationId: exports_external.string(),
   turnId: exports_external.string(),
   itemId: exports_external.string(),
+  order: exports_external.number().int().nonnegative(),
   delta: exports_external.string()
 });
+var AgentsUiConversationMessageUpsertEventSchema = exports_external.object({
+  type: exports_external.literal("messageUpsert"),
+  revision: exports_external.number().int().nonnegative(),
+  conversationId: exports_external.string(),
+  message: AgentsUiConversationMessageSchema
+});
+var AgentsUiConversationStatusEventSchema = exports_external.object({
+  type: exports_external.literal("conversationStatus"),
+  revision: exports_external.number().int().nonnegative(),
+  conversationId: exports_external.string(),
+  running: exports_external.boolean(),
+  activeTurnId: exports_external.string().nullable()
+});
 var AgentsUiConversationErrorEventSchema = exports_external.object({
   type: exports_external.literal("error"),
   message: exports_external.string()
 });
 var AgentsUiConversationEventSchema = exports_external.discriminatedUnion("type", [
-  AgentsUiConversationSnapshotEventSchema,
   AgentsUiConversationMessageDeltaEventSchema,
+  AgentsUiConversationMessageUpsertEventSchema,
+  AgentsUiConversationStatusEventSchema,
   AgentsUiConversationErrorEventSchema
 ]);
 var WorktreeListResponseSchema = exports_external.object({
@@ -12845,6 +12868,14 @@ function isStringArray(raw) {
 // backend/src/adapters/codex-app-server.ts
 var CodexAppServerApprovalPolicySchema = exports_external.enum(["untrusted", "on-failure", "on-request", "never"]);
 var UnknownValueSchema = exports_external.custom(() => true);
+var JsonValueSchema = exports_external.union([
+  exports_external.string(),
+  exports_external.number(),
+  exports_external.boolean(),
+  exports_external.null(),
+  exports_external.array(UnknownValueSchema),
+  exports_external.record(UnknownValueSchema)
+]);
 var CodexAppServerContentItemSchema = exports_external.object({
   type: exports_external.string(),
   text: exports_external.string().optional()
@@ -12859,9 +12890,103 @@ var CodexAppServerAgentMessageItemSchema = exports_external.object({
   id: exports_external.string(),
   text: exports_external.string().optional(),
   message: exports_external.string().optional(),
-  phase: exports_external.string().optional(),
+  phase: exports_external.string().nullable().optional(),
   memoryCitation: UnknownValueSchema.optional()
 });
+var CodexAppServerCommandActionSchema = exports_external.object({
+  type: exports_external.string(),
+  command: exports_external.string().optional(),
+  path: exports_external.string().nullable().optional()
+});
+var CodexAppServerCommandExecutionItemSchema = exports_external.object({
+  type: exports_external.literal("commandExecution"),
+  id: exports_external.string(),
+  command: exports_external.string(),
+  cwd: exports_external.string().nullable(),
+  status: exports_external.enum(["inProgress", "completed", "failed", "declined"]),
+  commandActions: exports_external.array(CodexAppServerCommandActionSchema).default([]),
+  aggregatedOutput: exports_external.string().nullable(),
+  exitCode: exports_external.number().nullable(),
+  durationMs: exports_external.number().nullable()
+});
+var CodexAppServerPatchChangeKindSchema = exports_external.union([
+  exports_external.object({ type: exports_external.literal("add") }),
+  exports_external.object({ type: exports_external.literal("delete") }),
+  exports_external.object({ type: exports_external.literal("update"), move_path: exports_external.string().nullable() })
+]);
+var CodexAppServerFileUpdateChangeSchema = exports_external.object({
+  path: exports_external.string(),
+  kind: CodexAppServerPatchChangeKindSchema,
+  diff: exports_external.string()
+});
+var CodexAppServerFileChangeItemSchema = exports_external.object({
+  type: exports_external.literal("fileChange"),
+  id: exports_external.string(),
+  changes: exports_external.array(CodexAppServerFileUpdateChangeSchema),
+  status: exports_external.enum(["inProgress", "completed", "failed", "declined"])
+});
+var CodexAppServerMcpToolCallResultSchema = exports_external.object({
+  content: exports_external.array(JsonValueSchema),
+  structuredContent: JsonValueSchema,
+  _meta: JsonValueSchema
+});
+var CodexAppServerMcpToolCallErrorSchema = exports_external.object({
+  message: exports_external.string()
+});
+var CodexAppServerMcpToolCallItemSchema = exports_external.object({
+  type: exports_external.literal("mcpToolCall"),
+  id: exports_external.string(),
+  server: exports_external.string(),
+  tool: exports_external.string(),
+  status: exports_external.enum(["inProgress", "completed", "failed"]),
+  arguments: JsonValueSchema,
+  mcpAppResourceUri: exports_external.string().optional(),
+  pluginId: exports_external.string().nullable(),
+  result: CodexAppServerMcpToolCallResultSchema.nullable(),
+  error: CodexAppServerMcpToolCallErrorSchema.nullable(),
+  durationMs: exports_external.number().nullable()
+});
+var CodexAppServerDynamicToolCallContentItemSchema = exports_external.union([
+  exports_external.object({ type: exports_external.literal("inputText"), text: exports_external.string() }),
+  exports_external.object({ type: exports_external.literal("inputImage"), imageUrl: exports_external.string() })
+]);
+var CodexAppServerDynamicToolCallItemSchema = exports_external.object({
+  type: exports_external.literal("dynamicToolCall"),
+  id: exports_external.string(),
+  namespace: exports_external.string().nullable(),
+  tool: exports_external.string(),
+  arguments: JsonValueSchema,
+  status: exports_external.enum(["inProgress", "completed", "failed"]),
+  contentItems: exports_external.array(CodexAppServerDynamicToolCallContentItemSchema).nullable(),
+  success: exports_external.boolean().nullable(),
+  durationMs: exports_external.number().nullable()
+});
+var CodexAppServerWebSearchActionSchema = exports_external.union([
+  exports_external.object({ type: exports_external.literal("search"), query: exports_external.string().nullable(), queries: exports_external.array(exports_external.string()).nullable() }),
+  exports_external.object({ type: exports_external.literal("openPage"), url: exports_external.string().nullable() }),
+  exports_external.object({ type: exports_external.literal("findInPage"), url: exports_external.string().nullable(), pattern: exports_external.string().nullable() }),
+  exports_external.object({ type: exports_external.literal("other") })
+]);
+var CodexAppServerWebSearchItemSchema = exports_external.object({
+  type: exports_external.literal("webSearch"),
+  id: exports_external.string(),
+  query: exports_external.string(),
+  action: CodexAppServerWebSearchActionSchema.nullable()
+});
+var CodexAppServerIgnoredItemSchema = exports_external.object({
+  type: exports_external.enum([
+    "hookPrompt",
+    "plan",
+    "reasoning",
+    "collabAgentToolCall",
+    "imageView",
+    "imageGeneration",
+    "enteredReviewMode",
+    "exitedReviewMode",
+    "contextCompaction"
+  ]),
+  id: exports_external.string()
+});
 var CodexAppServerGenericItemSchema = exports_external.object({
   type: exports_external.string(),
   id: exports_external.string()
@@ -12869,6 +12994,12 @@ var CodexAppServerGenericItemSchema = exports_external.object({
 var CodexAppServerThreadItemSchema = exports_external.union([
   CodexAppServerUserMessageItemSchema,
   CodexAppServerAgentMessageItemSchema,
+  CodexAppServerCommandExecutionItemSchema,
+  CodexAppServerFileChangeItemSchema,
+  CodexAppServerMcpToolCallItemSchema,
+  CodexAppServerDynamicToolCallItemSchema,
+  CodexAppServerWebSearchItemSchema,
+  CodexAppServerIgnoredItemSchema,
   CodexAppServerGenericItemSchema
 ]);
 var CodexAppServerTurnSchema = exports_external.object({
@@ -12958,7 +13089,31 @@ var CodexAppServerInitializeResponseSchema = exports_external.object({
   platformFamily: exports_external.string(),
   platformOs: exports_external.string()
 });
-
+function readCodexAppServerStdoutLines(input) {
+  let buffer = input.buffer + (input.chunk ? input.decoder.decode(input.chunk, { stream: true }) : input.decoder.decode());
+  const lines = [];
+  while (true) {
+    const newlineIndex = buffer.indexOf(`
+`);
+    if (newlineIndex === -1)
+      break;
+    const line = buffer.slice(0, newlineIndex).trim();
+    buffer = buffer.slice(newlineIndex + 1);
+    if (line.length > 0)
+      lines.push(line);
+  }
+  if (!input.chunk) {
+    const finalLine = buffer.trim();
+    buffer = "";
+    if (finalLine.length > 0)
+      lines.push(finalLine);
+  }
+  return { buffer, lines };
+}
+function parseCodexAppServerThreadItem(raw) {
+  const parsed = CodexAppServerThreadItemSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
 class CodexAppServerRequestError extends Error {
   code;
   data;
@@ -12972,7 +13127,6 @@ class CodexAppServerRequestError extends Error {
 class CodexAppServerClient {
   opts;
   encoder = new TextEncoder;
-  decoder = new TextDecoder;
   listeners = new Set;
   pending = new Map;
   nextId = 1;
@@ -13059,25 +13213,30 @@ class CodexAppServerClient {
   startStdoutLoop(proc) {
     (async () => {
       const reader = proc.stdout.getReader();
+      const decoder = new TextDecoder;
       let buffer = "";
       try {
         while (true) {
           const { done, value } = await reader.read();
           if (done)
             break;
-          buffer += this.decoder.decode(value);
-          while (true) {
-            const newlineIndex = buffer.indexOf(`
-`);
-            if (newlineIndex === -1)
-              break;
-            const line = buffer.slice(0, newlineIndex).trim();
-            buffer = buffer.slice(newlineIndex + 1);
-            if (line.length === 0)
-              continue;
+          const decoded2 = readCodexAppServerStdoutLines({
+            decoder,
+            buffer,
+            chunk: value
+          });
+          buffer = decoded2.buffer;
+          for (const line of decoded2.lines) {
             this.handleStdoutLine(line);
           }
         }
+        const decoded = readCodexAppServerStdoutLines({
+          decoder,
+          buffer
+        });
+        for (const line of decoded.lines) {
+          this.handleStdoutLine(line);
+        }
       } catch (error) {
         if (this.proc === proc) {
           log.error("[agents] codex app-server stdout reader failed", error);
@@ -13088,12 +13247,13 @@ class CodexAppServerClient {
   startStderrLoop(proc) {
     (async () => {
       const reader = proc.stderr.getReader();
+      const decoder = new TextDecoder;
       try {
         while (true) {
           const { done, value } = await reader.read();
           if (done)
             break;
-          const chunk = this.decoder.decode(value).trim();
+          const chunk = decoder.decode(value, { stream: true }).trim();
           if (chunk.length > 0) {
             log.debug(`[agents] codex app-server stderr: ${chunk}`);
           }
@@ -14723,14 +14883,26 @@ async function createLinearIssue(input) {
 }
 
 // backend/src/services/conversation-export-service.ts
+var WebmuxConversationAttachmentMessageSchema = AgentsUiConversationMessageSchema.extend({
+  order: exports_external.number().int().nonnegative().optional(),
+  kind: AgentsUiConversationMessageKindSchema.optional()
+});
 var WebmuxConversationAttachmentPayloadSchema = exports_external.object({
   webmux: exports_external.literal(1),
   branch: exports_external.string(),
   baseBranch: exports_external.string().nullable(),
   agent: AgentIdSchema.nullable(),
   createdAt: exports_external.string(),
-  conversation: exports_external.array(AgentsUiConversationMessageSchema)
+  conversation: exports_external.array(WebmuxConversationAttachmentMessageSchema).transform((messages) => messages.map((message, order) => ({
+    ...message,
+    order: message.order ?? order,
+    kind: message.kind ?? "text"
+  })))
 });
+function parseWebmuxConversationAttachmentPayload(raw) {
+  const parsed = WebmuxConversationAttachmentPayloadSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
 var defaultSeedFromLinearDeps = {
   fetchIssueWithAttachments,
   downloadWebmuxAttachment: downloadWebmuxAttachmentDefault
@@ -14907,11 +15079,11 @@ async function downloadWebmuxAttachmentDefault(url) {
       return { ok: false, error: `Asset download failed ${res.status}` };
     }
     const text = await res.text();
-    const parsed = WebmuxConversationAttachmentPayloadSchema.safeParse(JSON.parse(text));
-    if (!parsed.success) {
+    const parsed = parseWebmuxConversationAttachmentPayload(JSON.parse(text));
+    if (!parsed) {
       return { ok: false, error: "Asset is not a webmux conversation payload" };
     }
-    return { ok: true, data: parsed.data };
+    return { ok: true, data: parsed };
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     return { ok: false, error: msg };
@@ -15500,9 +15672,9 @@ class BunTmuxGateway {
 
 // backend/src/domain/policies.ts
 var INVALID_BRANCH_CHARS_RE = /[~^:?*\[\]\\]+/g;
-var UNSAFE_ENV_KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var VALID_WORKTREE_NAME_RE = /^[a-z0-9][a-z0-9\-_./]*$/;
-var VALID_INSTANCE_PREFIX_RE = /^[a-z0-9][a-z0-9\-]*$/;
+var UNSAFE_ENV_KEY_RE = /^[a-z_][a-z0-9_]*$/i;
+var VALID_WORKTREE_NAME_RE = /^[a-z0-9][a-z0-9\-_./]*$/i;
+var VALID_INSTANCE_PREFIX_RE = /^[a-z0-9][a-z0-9\-]*$/i;
 function sanitizeBranchName(raw) {
   return raw.toLowerCase().replace(/\s+/g, "-").replace(INVALID_BRANCH_CHARS_RE, "").replace(/@\{/g, "").replace(/\.{2,}/g, ".").replace(/\/{2,}/g, "/").replace(/-{2,}/g, "-").replace(/^[.\-/]+|[.\-/]+$/g, "").replace(/\.lock$/i, "");
 }
@@ -17769,184 +17941,6 @@ function startAutoPullMonitor(deps, intervalMs) {
   return startSerializedInterval(run, intervalMs);
 }
 
-// backend/src/services/agents-ui-stream-service.ts
-function readNotificationParams(raw) {
-  return isRecord3(raw) ? raw : null;
-}
-function readThreadId(raw) {
-  return typeof raw === "string" && raw.length > 0 ? raw : null;
-}
-function readNotificationItemType(raw) {
-  if (!isRecord3(raw))
-    return null;
-  return typeof raw.type === "string" ? raw.type : null;
-}
-function readAgentsNotificationThreadId(notification) {
-  const params = readNotificationParams(notification.params);
-  if (!params)
-    return null;
-  return readThreadId(params.threadId);
-}
-function buildAgentsUiMessageDeltaEvent(notification) {
-  if (notification.method !== "item/agentMessage/delta")
-    return null;
-  const params = readNotificationParams(notification.params);
-  if (!params)
-    return null;
-  const threadId = readThreadId(params.threadId);
-  const turnId = readThreadId(params.turnId);
-  const itemId = readThreadId(params.itemId);
-  const delta = typeof params.delta === "string" ? params.delta : null;
-  if (!threadId || !turnId || !itemId || delta === null)
-    return null;
-  return {
-    type: "messageDelta",
-    conversationId: threadId,
-    turnId,
-    itemId,
-    delta
-  };
-}
-function shouldRefreshAgentsConversationSnapshot(notification) {
-  switch (notification.method) {
-    case "turn/started":
-    case "turn/completed":
-    case "thread/status/changed":
-      return readAgentsNotificationThreadId(notification) !== null;
-    case "item/completed": {
-      const params = readNotificationParams(notification.params);
-      if (!params)
-        return false;
-      const itemType = readNotificationItemType(params.item);
-      return itemType === "userMessage" || itemType === "agentMessage";
-    }
-    default:
-      return false;
-  }
-}
-
-// backend/src/services/agents-ui-action-service.ts
-function classifyAgentsTerminalWorktreeError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (message.startsWith("No open tmux window found for worktree: ")) {
-    return { status: 409, error: message };
-  }
-  if (message.startsWith("Worktree not found: ")) {
-    return { status: 404, error: message };
-  }
-  return null;
-}
-
-// backend/src/services/snapshot-service.ts
-function formatElapsedSince(startedAt, now) {
-  if (!startedAt)
-    return "";
-  const startedMs = Date.parse(startedAt);
-  if (Number.isNaN(startedMs))
-    return "";
-  const diffMs = Math.max(0, now().getTime() - startedMs);
-  const diffMinutes = Math.floor(diffMs / 60000);
-  if (diffMinutes < 1)
-    return "0m";
-  if (diffMinutes < 60)
-    return `${diffMinutes}m`;
-  const diffHours = Math.floor(diffMinutes / 60);
-  if (diffHours < 24)
-    return `${diffHours}h`;
-  const diffDays = Math.floor(diffHours / 24);
-  return `${diffDays}d`;
-}
-function clonePrEntry(pr) {
-  return {
-    ...pr,
-    ciChecks: pr.ciChecks.map((check) => ({ ...check })),
-    comments: pr.comments.map((comment) => ({ ...comment }))
-  };
-}
-function mapCreationSnapshot(creating) {
-  return creating ? {
-    phase: creating.phase
-  } : null;
-}
-function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue, findAgentLabel) {
-  return {
-    branch: state.branch,
-    label: state.label,
-    ...state.baseBranch ? { baseBranch: state.baseBranch } : {},
-    path: state.path,
-    dir: state.path,
-    archived: isArchived(state.path),
-    profile: state.profile,
-    agentName: state.agentName,
-    agentLabel: findAgentLabel ? findAgentLabel(state.agentName) : state.agentName,
-    agentTerminalStale: state.agentTerminalStale,
-    mux: state.session.exists,
-    dirty: state.git.dirty,
-    unpushed: state.git.aheadCount > 0,
-    paneCount: state.session.paneCount,
-    status: creating ? "creating" : state.agent.lifecycle,
-    elapsed: formatElapsedSince(state.agent.lastStartedAt, now),
-    services: state.services.map((service) => ({ ...service })),
-    prs: state.prs.map((pr) => clonePrEntry(pr)),
-    linearIssue: findLinearIssue ? findLinearIssue(state.branch) : null,
-    creation: mapCreationSnapshot(creating),
-    source: state.source,
-    oneshot: state.oneshot
-  };
-}
-function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue, findAgentLabel) {
-  return {
-    branch: creating.branch,
-    label: null,
-    ...creating.baseBranch ? { baseBranch: creating.baseBranch } : {},
-    path: creating.path,
-    dir: creating.path,
-    archived: isArchived(creating.path),
-    profile: creating.profile,
-    agentName: creating.agentName,
-    agentLabel: findAgentLabel ? findAgentLabel(creating.agentName) : creating.agentName,
-    agentTerminalStale: false,
-    mux: false,
-    dirty: false,
-    unpushed: false,
-    paneCount: 0,
-    status: "creating",
-    elapsed: "",
-    services: [],
-    prs: [],
-    linearIssue: findLinearIssue ? findLinearIssue(creating.branch) : null,
-    creation: mapCreationSnapshot(creating),
-    source: creating.source,
-    oneshot: null
-  };
-}
-function buildWorktreeSnapshots(input) {
-  const now = input.now ?? (() => new Date);
-  const isArchived = input.isArchived ?? (() => false);
-  const creatingWorktrees = input.creatingWorktrees ?? [];
-  const creatingByBranch = new Map(creatingWorktrees.map((worktree) => [worktree.branch, worktree]));
-  const runtimeWorktrees = input.runtime.listWorktrees();
-  const runtimeBranches = new Set(runtimeWorktrees.map((worktree) => worktree.branch));
-  const worktrees = runtimeWorktrees.map((state) => mapWorktreeSnapshot(state, now, creatingByBranch.get(state.branch) ?? null, isArchived, input.findLinearIssue, input.findAgentLabel));
-  for (const creating of creatingWorktrees) {
-    if (!runtimeBranches.has(creating.branch)) {
-      worktrees.push(mapCreatingWorktreeSnapshot(creating, isArchived, input.findLinearIssue, input.findAgentLabel));
-    }
-  }
-  worktrees.sort((left, right) => left.branch.localeCompare(right.branch));
-  return worktrees;
-}
-function buildProjectSnapshot(input) {
-  return {
-    project: {
-      name: input.projectName,
-      mainBranch: input.mainBranch
-    },
-    worktrees: buildWorktreeSnapshots(input),
-    notifications: input.notifications.map((notification) => ({ ...notification }))
-  };
-}
-
 // backend/src/services/agents-ui-service.ts
 function cloneConversationMeta(meta) {
   return meta ? { ...meta } : null;
@@ -17977,43 +17971,1257 @@ function buildAgentsUiWorktreeSummary(worktree, conversation) {
   };
 }
 
-// backend/src/services/worktree-conversation-result.ts
-function ok(data) {
-  return { ok: true, data };
-}
-function err(status, error) {
-  return { ok: false, status, error };
-}
-
-// backend/src/services/claude-conversation-service.ts
-function isClaudeWorktree(worktree) {
-  return worktree.agentName === "claude";
-}
-function isClaudeConversationMeta(meta) {
-  return meta?.provider === "claudeCode";
-}
-function buildPendingConversationId(worktree) {
-  return `claude-pending:${worktree.path}`;
+// backend/src/services/codex-session-log-service.ts
+var TOOL_OUTPUT_TRUNCATE_LIMIT = 12000;
+function readString2(raw) {
+  return typeof raw === "string" && raw.length > 0 ? raw : null;
 }
-function buildClaudeConversationMeta(sessionId, cwd, now) {
+function parseLogLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord3(parsed))
+    return null;
   return {
-    provider: "claudeCode",
-    conversationId: sessionId,
-    sessionId,
-    cwd,
-    lastSeenAt: now.toISOString()
+    timestamp: readString2(parsed.timestamp),
+    type: readString2(parsed.type),
+    payload: isRecord3(parsed.payload) ? parsed.payload : null
   };
 }
-function sameConversationMeta(left, right) {
-  return left?.provider === right.provider && left.conversationId === right.conversationId && left.cwd === right.cwd;
+function truncate2(text, limit = TOOL_OUTPUT_TRUNCATE_LIMIT) {
+  if (text.length <= limit)
+    return text;
+  return `${text.slice(0, limit)}... (truncated, ${text.length - limit} more chars)`;
 }
-function normalizeSessionMessages(messages) {
-  return messages.map((message) => ({
+function compactJson2(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function readReasoningSummary(raw) {
+  if (!Array.isArray(raw))
+    return "";
+  return raw.map((entry) => {
+    if (typeof entry === "string")
+      return entry;
+    if (!isRecord3(entry))
+      return "";
+    if (typeof entry.text === "string")
+      return entry.text;
+    if (typeof entry.summary === "string")
+      return entry.summary;
+    return "";
+  }).filter((text) => text.trim().length > 0).join(`
+`).trim();
+}
+function parseArgumentsRecord(raw) {
+  if (!raw)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  return isRecord3(parsed) ? parsed : null;
+}
+function readToolCommand(toolName, argumentsText) {
+  if (toolName === "apply_patch")
+    return "apply_patch";
+  const args = parseArgumentsRecord(argumentsText);
+  if (!args)
+    return null;
+  if (toolName === "exec_command" && typeof args.cmd === "string")
+    return args.cmd;
+  return null;
+}
+function readToolCwd(argumentsText) {
+  const args = parseArgumentsRecord(argumentsText);
+  if (!args)
+    return null;
+  return typeof args.workdir === "string" ? args.workdir : null;
+}
+function buildToolUseText(toolName, argumentsText) {
+  const command = readToolCommand(toolName, argumentsText);
+  if (command)
+    return command;
+  return argumentsText?.trim() ?? "";
+}
+function readOutputExitCode(output) {
+  const processMatch = output.match(/Process exited with code (-?\d+)/);
+  if (processMatch?.[1])
+    return Number(processMatch[1]);
+  const exitMatch = output.match(/^Exit code: (-?\d+)/m);
+  if (exitMatch?.[1])
+    return Number(exitMatch[1]);
+  return null;
+}
+function readOutputStatus(output) {
+  const exitCode = readOutputExitCode(output);
+  if (exitCode !== null)
+    return exitCode === 0 ? "completed" : "failed";
+  return output.startsWith("apply_patch verification failed") ? "failed" : "completed";
+}
+function pushMessage(messages, message) {
+  messages.push({
+    ...message,
+    order: messages.length
+  });
+}
+function hasDuplicateTextMessage(input) {
+  return input.messages.some((message) => message.turnId === input.turnId && message.role === input.role && message.kind === "text" && message.text === input.text && message.phase === input.phase);
+}
+function finalizeToolStatuses(messages) {
+  const resultByCallId = new Map;
+  for (const message of messages) {
+    if (message.kind === "toolResult" && message.toolCallId) {
+      resultByCallId.set(message.toolCallId, message);
+    }
+  }
+  return messages.map((message) => {
+    if (message.kind !== "toolUse" || !message.toolCallId)
+      return message;
+    const result = resultByCallId.get(message.toolCallId);
+    if (!result)
+      return message;
+    return {
+      ...message,
+      status: result.status,
+      ...result.exitCode !== undefined ? { exitCode: result.exitCode } : {},
+      ...result.durationMs !== undefined ? { durationMs: result.durationMs } : {}
+    };
+  });
+}
+function parseCodexSessionMessages(text) {
+  const messages = [];
+  const toolCallMetadata = new Map;
+  let currentTurnId = null;
+  let blockIndex = 0;
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+      continue;
+    const record = parseLogLine(trimmed);
+    if (!record?.payload)
+      continue;
+    if (record.type === "event_msg") {
+      const eventType = readString2(record.payload.type);
+      if (eventType === "task_started") {
+        currentTurnId = readString2(record.payload.turn_id);
+        blockIndex = 0;
+        continue;
+      }
+      if (eventType === "task_complete" || eventType === "turn_aborted") {
+        currentTurnId = null;
+        continue;
+      }
+      if (eventType === "user_message" && currentTurnId) {
+        const text2 = readString2(record.payload.message);
+        if (!text2 || hasDuplicateTextMessage({ messages, turnId: currentTurnId, role: "user", text: text2 }))
+          continue;
+        pushMessage(messages, {
+          id: `user:${currentTurnId}:${blockIndex}`,
+          turnId: currentTurnId,
+          role: "user",
+          kind: "text",
+          text: text2,
+          status: "completed",
+          createdAt: record.timestamp
+        });
+        blockIndex += 1;
+        continue;
+      }
+      if (eventType === "agent_message" && currentTurnId) {
+        const text2 = readString2(record.payload.message);
+        if (!text2)
+          continue;
+        const phase = readString2(record.payload.phase) ?? undefined;
+        if (hasDuplicateTextMessage({ messages, turnId: currentTurnId, role: "assistant", text: text2, phase }))
+          continue;
+        pushMessage(messages, {
+          id: `assistant:${currentTurnId}:${blockIndex}`,
+          turnId: currentTurnId,
+          role: "assistant",
+          kind: phase === "analysis" ? "thinking" : "text",
+          ...phase ? { phase } : {},
+          text: text2,
+          status: "completed",
+          createdAt: record.timestamp
+        });
+        blockIndex += 1;
+      }
+      continue;
+    }
+    if (record.type !== "response_item" || !currentTurnId)
+      continue;
+    const payloadType = readString2(record.payload.type);
+    if (payloadType === "reasoning") {
+      const summary = readReasoningSummary(record.payload.summary);
+      if (summary.length === 0)
+        continue;
+      pushMessage(messages, {
+        id: `reasoning:${currentTurnId}:${blockIndex}`,
+        turnId: currentTurnId,
+        role: "assistant",
+        kind: "thinking",
+        phase: "analysis",
+        text: summary,
+        status: "completed",
+        createdAt: record.timestamp
+      });
+      blockIndex += 1;
+      continue;
+    }
+    if (payloadType === "function_call" || payloadType === "custom_tool_call") {
+      const callId = readString2(record.payload.call_id);
+      if (!callId)
+        continue;
+      const toolName = readString2(record.payload.name) ?? "tool";
+      const argumentsText = payloadType === "custom_tool_call" ? typeof record.payload.input === "string" ? record.payload.input : compactJson2(record.payload.input ?? {}) : typeof record.payload.arguments === "string" ? record.payload.arguments : compactJson2(record.payload.arguments ?? {});
+      const command = readToolCommand(toolName, argumentsText);
+      const cwd = payloadType === "custom_tool_call" ? null : readToolCwd(argumentsText);
+      toolCallMetadata.set(callId, {
+        toolName,
+        ...command ? { command } : {},
+        ...cwd ? { cwd } : {}
+      });
+      pushMessage(messages, {
+        id: callId,
+        turnId: currentTurnId,
+        role: "assistant",
+        kind: "toolUse",
+        toolName,
+        toolCallId: callId,
+        text: payloadType === "custom_tool_call" ? toolName : buildToolUseText(toolName, argumentsText),
+        ...command ? { command } : {},
+        ...cwd ? { cwd } : {},
+        status: record.payload.status === "failed" ? "failed" : "completed",
+        createdAt: record.timestamp
+      });
+      blockIndex += 1;
+      continue;
+    }
+    if (payloadType === "function_call_output" || payloadType === "custom_tool_call_output") {
+      const callId = readString2(record.payload.call_id);
+      if (!callId)
+        continue;
+      const metadata = toolCallMetadata.get(callId);
+      const output = typeof record.payload.output === "string" ? record.payload.output.trimEnd() : compactJson2(record.payload.output ?? "");
+      const exitCode = readOutputExitCode(output);
+      pushMessage(messages, {
+        id: `${callId}:result`,
+        turnId: currentTurnId,
+        role: "user",
+        kind: "toolResult",
+        ...metadata?.toolName ? { toolName: metadata.toolName } : {},
+        toolCallId: callId,
+        text: truncate2(output),
+        ...metadata?.command ? { command: metadata.command } : {},
+        ...metadata?.cwd ? { cwd: metadata.cwd } : {},
+        status: readOutputStatus(output),
+        createdAt: record.timestamp,
+        exitCode
+      });
+      blockIndex += 1;
+    }
+  }
+  return finalizeToolStatuses(messages);
+}
+async function readCodexSessionMessages(thread) {
+  if (!thread.path)
+    return [];
+  try {
+    const file = Bun.file(thread.path);
+    if (!await file.exists())
+      return [];
+    return parseCodexSessionMessages(await file.text());
+  } catch {
+    return [];
+  }
+}
+
+// backend/src/services/worktree-conversation-result.ts
+function ok(data) {
+  return { ok: true, data };
+}
+function err(status, error) {
+  return { ok: false, status, error };
+}
+
+// backend/src/services/worktree-conversation-service.ts
+function resolveCodexAppServerLaunchContext(input) {
+  if (input.worktree.agentName !== "codex" || input.meta.agent !== "codex") {
+    return err(409, "Codex web chat is only available for Codex worktrees");
+  }
+  if (!input.profile) {
+    return err(409, `Profile is missing for Codex web chat: ${input.meta.profile}`);
+  }
+  if (input.meta.runtime !== "host" || input.profile.runtime !== "host") {
+    return err(409, "Codex web chat is only available for host-runtime worktrees. Use the terminal for Docker worktrees.");
+  }
+  if (input.profile.yolo !== true) {
+    return err(409, "Codex web chat requires a yolo profile to preserve the Codex approval policy. Use the terminal for this worktree.");
+  }
+  return ok({
+    approvalPolicy: "never",
+    personality: "pragmatic",
+    sandbox: "danger-full-access"
+  });
+}
+function isCodexWorktree(worktree) {
+  return worktree.agentName === "codex";
+}
+function isCodexConversationMeta(meta) {
+  return meta?.provider === "codexAppServer";
+}
+function toIsoTimestamp(epochSeconds) {
+  if (epochSeconds === null)
+    return null;
+  return new Date(epochSeconds * 1000).toISOString();
+}
+function isUserMessageItem(item) {
+  return item.type === "userMessage";
+}
+function isAgentMessageItem(item) {
+  return item.type === "agentMessage";
+}
+function isCommandExecutionItem(item) {
+  return item.type === "commandExecution";
+}
+function isFileChangeItem(item) {
+  return item.type === "fileChange";
+}
+function isMcpToolCallItem(item) {
+  return item.type === "mcpToolCall";
+}
+function isDynamicToolCallItem(item) {
+  return item.type === "dynamicToolCall";
+}
+function isWebSearchItem(item) {
+  return item.type === "webSearch";
+}
+function extractUserText(item) {
+  return item.content.map((contentItem) => contentItem.text ?? "").join("").trim();
+}
+function extractAgentText(item) {
+  return item.text ?? item.message ?? "";
+}
+function commandExecutionStatus(item) {
+  switch (item.status) {
+    case "inProgress":
+      return "inProgress";
+    case "completed":
+      return item.exitCode !== null && item.exitCode !== 0 ? "failed" : "completed";
+    case "failed":
+    case "declined":
+      return "failed";
+  }
+}
+function commandExecutionDisplayText(item) {
+  const commands = item.commandActions.map((action) => action.command ?? "").filter((command) => command.length > 0);
+  return commands.length > 0 ? commands.join(" && ") : item.command;
+}
+function toolStatus(status) {
+  switch (status) {
+    case "inProgress":
+      return "inProgress";
+    case "completed":
+      return "completed";
+    case "failed":
+    case "declined":
+      return "failed";
+  }
+}
+function jsonDisplayText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value, null, 2) ?? "";
+}
+function patchChangeLabel(change) {
+  switch (change.kind.type) {
+    case "add":
+      return `add ${change.path}`;
+    case "delete":
+      return `delete ${change.path}`;
+    case "update":
+      return change.kind.move_path ? `move ${change.kind.move_path} -> ${change.path}` : `update ${change.path}`;
+  }
+}
+function fileChangeDisplayText(item) {
+  return item.changes.map(patchChangeLabel).join(`
+`);
+}
+function fileChangeResultText(item) {
+  return item.changes.map((change) => change.diff.trimEnd()).filter((diff) => diff.length > 0).join(`
+
+`);
+}
+function mcpContentText(content) {
+  if (isRecord3(content) && typeof content.text === "string")
+    return content.text;
+  return jsonDisplayText(content);
+}
+function mcpToolResultText(item) {
+  if (item.error)
+    return item.error.message;
+  if (!item.result)
+    return "";
+  const parts = item.result.content.map(mcpContentText);
+  if (item.result.structuredContent !== null) {
+    parts.push(jsonDisplayText(item.result.structuredContent));
+  }
+  return parts.join(`
+
+`).trim();
+}
+function dynamicToolName(item) {
+  return item.namespace ? `${item.namespace}.${item.tool}` : item.tool;
+}
+function dynamicToolContentText(content) {
+  switch (content.type) {
+    case "inputText":
+      return content.text;
+    case "inputImage":
+      return content.imageUrl;
+  }
+}
+function dynamicToolResultText(item) {
+  return (item.contentItems ?? []).map(dynamicToolContentText).join(`
+
+`).trim();
+}
+function webSearchDisplayText(item) {
+  const action = item.action;
+  if (!action)
+    return item.query;
+  switch (action.type) {
+    case "search":
+      return action.queries?.join(`
+`) ?? action.query ?? item.query;
+    case "openPage":
+      return action.url ?? item.query;
+    case "findInPage":
+      return [action.url, action.pattern].filter((part) => part !== null).join(`
+`);
+    case "other":
+      return item.query;
+  }
+}
+function isActiveTurnStatus(status) {
+  return status === "inProgress" || status === "active" || status === "running" || status === "pending" || status === "queued";
+}
+function findActiveTurn(thread) {
+  for (let index = thread.turns.length - 1;index >= 0; index -= 1) {
+    const turn = thread.turns[index];
+    if (isActiveTurnStatus(turn.status))
+      return turn;
+  }
+  return null;
+}
+function buildCommandExecutionMessages(input) {
+  const { item, turnId, createdAt, order } = input;
+  const status = commandExecutionStatus(item);
+  const toolUse = {
+    id: item.id,
+    turnId,
+    order,
+    role: "assistant",
+    kind: "toolUse",
+    toolName: "shell",
+    toolCallId: item.id,
+    text: commandExecutionDisplayText(item),
+    command: item.command,
+    cwd: item.cwd ?? undefined,
+    status,
+    createdAt,
+    exitCode: item.exitCode,
+    durationMs: item.durationMs
+  };
+  const output = item.aggregatedOutput?.trimEnd() ?? "";
+  if (output.length === 0)
+    return [toolUse];
+  return [
+    toolUse,
+    {
+      id: `${item.id}:result`,
+      turnId,
+      order: order + 1,
+      role: "user",
+      kind: "toolResult",
+      toolName: "shell",
+      toolCallId: item.id,
+      text: output,
+      command: item.command,
+      cwd: item.cwd ?? undefined,
+      status,
+      createdAt,
+      exitCode: item.exitCode,
+      durationMs: item.durationMs
+    }
+  ];
+}
+function buildFileChangeMessages(input) {
+  const { item, turnId, createdAt, order } = input;
+  const status = toolStatus(item.status);
+  const toolUse = {
+    id: item.id,
+    turnId,
+    order,
+    role: "assistant",
+    kind: "toolUse",
+    toolName: "file change",
+    toolCallId: item.id,
+    text: fileChangeDisplayText(item),
+    status,
+    createdAt
+  };
+  const resultText = fileChangeResultText(item);
+  if (resultText.length === 0)
+    return [toolUse];
+  return [
+    toolUse,
+    {
+      id: `${item.id}:result`,
+      turnId,
+      order: order + 1,
+      role: "user",
+      kind: "toolResult",
+      toolName: "file change",
+      toolCallId: item.id,
+      text: resultText,
+      status,
+      createdAt
+    }
+  ];
+}
+function buildMcpToolCallMessages(input) {
+  const { item, turnId, createdAt, order } = input;
+  const status = item.error ? "failed" : toolStatus(item.status);
+  const toolName = `${item.server}.${item.tool}`;
+  const toolUse = {
+    id: item.id,
+    turnId,
+    order,
+    role: "assistant",
+    kind: "toolUse",
+    toolName,
+    toolCallId: item.id,
+    text: jsonDisplayText(item.arguments),
+    status,
+    createdAt,
+    durationMs: item.durationMs
+  };
+  const resultText = mcpToolResultText(item);
+  if (resultText.length === 0)
+    return [toolUse];
+  return [
+    toolUse,
+    {
+      id: `${item.id}:result`,
+      turnId,
+      order: order + 1,
+      role: "user",
+      kind: "toolResult",
+      toolName,
+      toolCallId: item.id,
+      text: resultText,
+      status,
+      createdAt,
+      durationMs: item.durationMs
+    }
+  ];
+}
+function buildDynamicToolCallMessages(input) {
+  const { item, turnId, createdAt, order } = input;
+  const status = item.success === false ? "failed" : toolStatus(item.status);
+  const toolName = dynamicToolName(item);
+  const toolUse = {
+    id: item.id,
+    turnId,
+    order,
+    role: "assistant",
+    kind: "toolUse",
+    toolName,
+    toolCallId: item.id,
+    text: jsonDisplayText(item.arguments),
+    status,
+    createdAt,
+    durationMs: item.durationMs
+  };
+  const resultText = dynamicToolResultText(item);
+  if (resultText.length === 0)
+    return [toolUse];
+  return [
+    toolUse,
+    {
+      id: `${item.id}:result`,
+      turnId,
+      order: order + 1,
+      role: "user",
+      kind: "toolResult",
+      toolName,
+      toolCallId: item.id,
+      text: resultText,
+      status,
+      createdAt,
+      durationMs: item.durationMs
+    }
+  ];
+}
+function buildWebSearchMessages(input) {
+  const { item, turnId, createdAt, order } = input;
+  return [{
+    id: item.id,
+    turnId,
+    order,
+    role: "assistant",
+    kind: "toolUse",
+    toolName: "web search",
+    toolCallId: item.id,
+    text: webSearchDisplayText(item),
+    status: "completed",
+    createdAt
+  }];
+}
+function buildCodexItemConversationMessages(input) {
+  const { item, turnId, turnStatus, createdAt, order, includeEmptyText = false } = input;
+  if (isUserMessageItem(item)) {
+    const text = extractUserText(item);
+    if (text.length === 0 && !includeEmptyText)
+      return [];
+    return [{
+      id: item.id,
+      turnId,
+      order,
+      role: "user",
+      kind: "text",
+      text,
+      status: "completed",
+      createdAt
+    }];
+  }
+  if (isAgentMessageItem(item)) {
+    const text = extractAgentText(item);
+    if (text.length === 0 && !includeEmptyText)
+      return [];
+    const phase = item.phase ?? undefined;
+    const isThinking = phase === "analysis";
+    return [{
+      id: item.id,
+      turnId,
+      order,
+      role: "assistant",
+      kind: isThinking ? "thinking" : "text",
+      phase,
+      text,
+      status: isActiveTurnStatus(turnStatus) ? "inProgress" : "completed",
+      createdAt
+    }];
+  }
+  if (isCommandExecutionItem(item))
+    return buildCommandExecutionMessages({ item, turnId, createdAt, order });
+  if (isFileChangeItem(item))
+    return buildFileChangeMessages({ item, turnId, createdAt, order });
+  if (isMcpToolCallItem(item))
+    return buildMcpToolCallMessages({ item, turnId, createdAt, order });
+  if (isDynamicToolCallItem(item))
+    return buildDynamicToolCallMessages({ item, turnId, createdAt, order });
+  if (isWebSearchItem(item))
+    return buildWebSearchMessages({ item, turnId, createdAt, order });
+  return [];
+}
+function buildConversationMessages(thread) {
+  const messages = [];
+  let order = 0;
+  for (const turn of thread.turns) {
+    for (const item of turn.items) {
+      const itemMessages = buildCodexItemConversationMessages({
+        item,
+        turnId: turn.id,
+        turnStatus: turn.status,
+        createdAt: toIsoTimestamp(isUserMessageItem(item) ? turn.startedAt : turn.completedAt ?? turn.startedAt),
+        order
+      });
+      messages.push(...itemMessages);
+      order += itemMessages.length;
+    }
+  }
+  return messages;
+}
+function buildConversationState(thread, sessionMessages = []) {
+  const activeTurn = findActiveTurn(thread);
+  const messages = sessionMessages.length > 0 ? sessionMessages : buildConversationMessages(thread);
+  return {
+    provider: "codexAppServer",
+    conversationId: thread.id,
+    cwd: thread.cwd,
+    running: thread.status.type === "active" || activeTurn !== null,
+    activeTurnId: activeTurn?.id ?? null,
+    messages
+  };
+}
+function selectDiscoveredThread(threads) {
+  if (threads.length === 0)
+    return null;
+  return [...threads].sort((left, right) => right.updatedAt - left.updatedAt)[0] ?? null;
+}
+function buildConversationMeta(thread, now) {
+  return {
+    provider: "codexAppServer",
+    conversationId: thread.id,
+    threadId: thread.id,
+    cwd: thread.cwd,
+    lastSeenAt: now.toISOString()
+  };
+}
+function sameConversationMeta(left, right) {
+  return left?.provider === right.provider && left.conversationId === right.conversationId && left.cwd === right.cwd;
+}
+function toWorktreeConversationResponse(worktree, conversationMeta, thread, sessionMessages) {
+  return {
+    worktree: buildAgentsUiWorktreeSummary(worktree, conversationMeta),
+    conversation: buildConversationState(thread, sessionMessages)
+  };
+}
+
+class WorktreeConversationService {
+  deps;
+  now;
+  readSessionMessages;
+  readMeta;
+  writeMeta;
+  constructor(deps) {
+    this.deps = deps;
+    this.now = deps.now ?? (() => new Date);
+    this.readSessionMessages = deps.readSessionMessages ?? readCodexSessionMessages;
+    this.readMeta = deps.readMeta ?? readWorktreeMeta;
+    this.writeMeta = deps.writeMeta ?? writeWorktreeMeta;
+  }
+  async attachWorktreeConversation(worktree) {
+    return await this.withResolvedConversation(worktree, true, async ({ conversationMeta, thread }) => {
+      const sessionMessages = await this.readSessionMessages(thread);
+      return ok(toWorktreeConversationResponse(worktree, conversationMeta, thread, sessionMessages));
+    });
+  }
+  async readWorktreeConversation(worktree) {
+    return await this.withResolvedConversation(worktree, false, async ({ conversationMeta, thread }) => {
+      const sessionMessages = await this.readSessionMessages(thread);
+      return ok(toWorktreeConversationResponse(worktree, conversationMeta, thread, sessionMessages));
+    });
+  }
+  async sendWorktreeConversationMessage(worktree, text) {
+    return await this.withResolvedConversation(worktree, true, async ({ thread, launchContext }) => {
+      const started = await this.deps.appServer.turnStart({
+        threadId: thread.id,
+        cwd: worktree.path,
+        approvalPolicy: launchContext.approvalPolicy,
+        input: [{ type: "text", text }]
+      });
+      return ok({
+        conversationId: thread.id,
+        turnId: started.turn.id,
+        running: true
+      });
+    });
+  }
+  async interruptWorktreeConversation(worktree) {
+    return await this.withResolvedConversation(worktree, false, async ({ thread }) => {
+      const conversation = buildConversationState(thread);
+      const turnId = conversation.activeTurnId;
+      if (!turnId) {
+        return err(409, "No active Codex turn to interrupt");
+      }
+      await this.deps.appServer.turnInterrupt({
+        threadId: thread.id,
+        turnId
+      });
+      return ok({
+        conversationId: thread.id,
+        turnId,
+        interrupted: true
+      });
+    });
+  }
+  async withResolvedConversation(worktree, allowCreate, fn) {
+    if (!isCodexWorktree(worktree)) {
+      return err(409, "Worktree chat is only available for Codex worktrees");
+    }
+    try {
+      const resolved = await this.resolveConversation(worktree, allowCreate);
+      if (!resolved.ok)
+        return resolved;
+      return await fn(resolved.data);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return err(502, message);
+    }
+  }
+  async resolveConversation(worktree, allowCreate) {
+    const gitDir = this.deps.git.resolveWorktreeGitDir(worktree.path);
+    const meta = await this.readMeta(gitDir);
+    if (!meta) {
+      return err(409, "Worktree metadata is missing");
+    }
+    const launchContextResult = await this.deps.resolveLaunchContext({ worktree, meta });
+    if (!launchContextResult.ok)
+      return launchContextResult;
+    const launchContext = launchContextResult.data;
+    const now = this.now();
+    const thread = await this.resolveThread(meta, worktree.path, allowCreate, launchContext);
+    if (!thread) {
+      return err(404, "No Codex thread could be resolved for this worktree");
+    }
+    const conversationMeta = buildConversationMeta(thread, now);
+    const nextMeta = sameConversationMeta(meta.conversation, conversationMeta) ? { ...meta, conversation: { ...conversationMeta, lastSeenAt: meta.conversation?.lastSeenAt ?? conversationMeta.lastSeenAt } } : { ...meta, conversation: conversationMeta };
+    if (!sameConversationMeta(meta.conversation, conversationMeta)) {
+      await this.writeMeta(gitDir, nextMeta);
+    }
+    return ok({
+      gitDir,
+      meta: nextMeta,
+      thread,
+      conversationMeta: nextMeta.conversation ?? conversationMeta,
+      launchContext
+    });
+  }
+  async resolveThread(meta, cwd, allowCreate, launchContext) {
+    const savedThreadId = isCodexConversationMeta(meta.conversation) ? meta.conversation.threadId : null;
+    if (savedThreadId) {
+      const savedThread = await this.tryLoadThread(savedThreadId, cwd, launchContext);
+      if (savedThread)
+        return savedThread;
+      log.warn(`[agents] saved codex thread missing, starting fresh conversation cwd=${cwd} threadId=${savedThreadId}`);
+    } else {
+      const discoveredThread = selectDiscoveredThread((await this.deps.appServer.threadList({
+        cwd,
+        limit: 20,
+        sortKey: "updated_at"
+      })).data);
+      if (discoveredThread) {
+        return await this.ensureThreadLoaded(discoveredThread.id, cwd, launchContext);
+      }
+    }
+    if (!allowCreate)
+      return null;
+    const started = await this.deps.appServer.threadStart({
+      cwd,
+      approvalPolicy: launchContext.approvalPolicy,
+      personality: launchContext.personality,
+      sandbox: launchContext.sandbox
+    });
+    return started.thread;
+  }
+  async tryLoadThread(threadId, cwd, launchContext) {
+    try {
+      return await this.ensureThreadLoaded(threadId, cwd, launchContext);
+    } catch {
+      return null;
+    }
+  }
+  async ensureThreadLoaded(threadId, cwd, launchContext) {
+    const initial = await this.deps.appServer.threadRead(threadId, false);
+    if (initial.thread.status.type === "notLoaded") {
+      await this.deps.appServer.threadResume({
+        threadId,
+        cwd,
+        approvalPolicy: launchContext.approvalPolicy,
+        personality: launchContext.personality,
+        sandbox: launchContext.sandbox
+      });
+    }
+    return (await this.deps.appServer.threadRead(threadId, true)).thread;
+  }
+}
+
+// backend/src/services/agents-ui-stream-service.ts
+function readNotificationParams(raw) {
+  return isRecord3(raw) ? raw : null;
+}
+function readThreadId(raw) {
+  return typeof raw === "string" && raw.length > 0 ? raw : null;
+}
+function readStatusType(raw) {
+  if (typeof raw === "string")
+    return raw;
+  if (!isRecord3(raw))
+    return null;
+  return typeof raw.type === "string" ? raw.type : null;
+}
+function readNotificationStatusType(notification) {
+  const params = readNotificationParams(notification.params);
+  if (!params)
+    return null;
+  return readStatusType(params.status) ?? (isRecord3(params.thread) ? readStatusType(params.thread.status) : null);
+}
+function isTerminalThreadStatus(statusType) {
+  return statusType === "idle" || statusType === "completed" || statusType === "interrupted" || statusType === "failed" || statusType === "systemError";
+}
+function readNumber(raw) {
+  return typeof raw === "number" ? raw : null;
+}
+function toIsoTimestampMs(epochMs) {
+  if (epochMs === null)
+    return null;
+  return new Date(epochMs).toISOString();
+}
+function readNotificationItem(notification) {
+  const params = readNotificationParams(notification.params);
+  if (!params)
+    return null;
+  return parseCodexAppServerThreadItem(params.item);
+}
+function orderSpanForItem(item) {
+  switch (item.type) {
+    case "userMessage":
+    case "agentMessage":
+    case "webSearch":
+      return 1;
+    case "commandExecution":
+    case "fileChange":
+    case "mcpToolCall":
+    case "dynamicToolCall":
+      return 2;
+    default:
+      return null;
+  }
+}
+function readAgentsNotificationThreadId(notification) {
+  const params = readNotificationParams(notification.params);
+  if (!params)
+    return null;
+  return readThreadId(params.threadId);
+}
+function buildAgentsUiMessageDeltaEvent(notification, order) {
+  if (notification.method !== "item/agentMessage/delta")
+    return null;
+  const params = readNotificationParams(notification.params);
+  if (!params)
+    return null;
+  const threadId = readThreadId(params.threadId);
+  const turnId = readThreadId(params.turnId);
+  const itemId = readThreadId(params.itemId);
+  const delta = typeof params.delta === "string" ? params.delta : null;
+  if (!threadId || !turnId || !itemId || delta === null)
+    return null;
+  return {
+    type: "messageDelta",
+    conversationId: threadId,
+    turnId,
+    itemId,
+    order,
+    delta
+  };
+}
+function buildAgentsUiMessageUpsertEvents(notification, order) {
+  if (notification.method !== "item/started" && notification.method !== "item/completed")
+    return [];
+  const params = readNotificationParams(notification.params);
+  if (!params)
+    return [];
+  const threadId = readThreadId(params.threadId);
+  const turnId = readThreadId(params.turnId);
+  if (!threadId || !turnId)
+    return [];
+  const item = readNotificationItem(notification);
+  if (!item)
+    return [];
+  const createdAt = toIsoTimestampMs(notification.method === "item/started" ? readNumber(params.startedAtMs) : readNumber(params.completedAtMs));
+  return buildCodexItemConversationMessages({
+    item,
+    turnId,
+    turnStatus: notification.method === "item/started" ? "inProgress" : "completed",
+    createdAt,
+    order,
+    includeEmptyText: true
+  }).map((message) => ({
+    type: "messageUpsert",
+    conversationId: threadId,
+    message
+  }));
+}
+function buildAgentsUiConversationStatusEvent(notification) {
+  if (notification.method !== "turn/started" && notification.method !== "turn/completed" && notification.method !== "thread/status/changed")
+    return null;
+  const params = readNotificationParams(notification.params);
+  if (!params)
+    return null;
+  const conversationId = readThreadId(params.threadId);
+  if (!conversationId)
+    return null;
+  if (notification.method === "thread/status/changed") {
+    if (!isTerminalThreadStatus(readNotificationStatusType(notification)))
+      return null;
+    return {
+      type: "conversationStatus",
+      conversationId,
+      running: false,
+      activeTurnId: null
+    };
+  }
+  if (notification.method === "turn/started") {
+    const activeTurnId = readThreadId(params.turnId);
+    if (!activeTurnId)
+      return null;
+    return {
+      type: "conversationStatus",
+      conversationId,
+      running: true,
+      activeTurnId
+    };
+  }
+  return {
+    type: "conversationStatus",
+    conversationId,
+    running: false,
+    activeTurnId: null
+  };
+}
+
+class AgentsConversationStreamSession {
+  deps;
+  revision = 0;
+  conversationId;
+  closed = false;
+  nextLiveOrder;
+  itemOrders = new Map;
+  constructor(deps) {
+    this.deps = deps;
+    this.conversationId = deps.conversationId;
+    this.nextLiveOrder = deps.nextOrder;
+  }
+  currentConversationId() {
+    return this.conversationId;
+  }
+  close() {
+    this.closed = true;
+  }
+  handleNotification(notification) {
+    if (this.closed)
+      return;
+    const notificationThreadId = readAgentsNotificationThreadId(notification);
+    if (!notificationThreadId || notificationThreadId !== this.conversationId)
+      return;
+    const statusEvent = buildAgentsUiConversationStatusEvent(notification);
+    if (statusEvent) {
+      this.deps.send({
+        ...statusEvent,
+        revision: this.nextRevision()
+      });
+      return;
+    }
+    const deltaOrder = this.orderForDeltaNotification(notification);
+    const deltaEvent = deltaOrder === null ? null : buildAgentsUiMessageDeltaEvent(notification, deltaOrder);
+    if (deltaEvent) {
+      this.deps.send({
+        ...deltaEvent,
+        revision: this.nextRevision()
+      });
+      return;
+    }
+    const upsertOrder = this.orderForUpsertNotification(notification);
+    if (upsertOrder !== null) {
+      for (const upsertEvent of buildAgentsUiMessageUpsertEvents(notification, upsertOrder)) {
+        this.deps.send({
+          ...upsertEvent,
+          revision: this.nextRevision()
+        });
+      }
+    }
+  }
+  nextRevision() {
+    this.revision += 1;
+    return this.revision;
+  }
+  reserveOrder(itemId, span) {
+    const existing = this.itemOrders.get(itemId);
+    if (existing !== undefined)
+      return existing;
+    const order = this.nextLiveOrder;
+    this.nextLiveOrder += span;
+    this.itemOrders.set(itemId, order);
+    return order;
+  }
+  orderForDeltaNotification(notification) {
+    if (notification.method !== "item/agentMessage/delta")
+      return null;
+    const params = readNotificationParams(notification.params);
+    if (!params)
+      return null;
+    const itemId = readThreadId(params.itemId);
+    return itemId ? this.reserveOrder(itemId, 1) : null;
+  }
+  orderForUpsertNotification(notification) {
+    if (notification.method !== "item/started" && notification.method !== "item/completed")
+      return null;
+    const params = readNotificationParams(notification.params);
+    if (!params || !isRecord3(params.item))
+      return null;
+    const itemId = readThreadId(params.item.id);
+    const item = readNotificationItem(notification);
+    if (!itemId || !item)
+      return null;
+    const orderSpan = orderSpanForItem(item);
+    return orderSpan === null ? null : this.reserveOrder(itemId, orderSpan);
+  }
+}
+
+// backend/src/services/agents-ui-action-service.ts
+function classifyAgentsTerminalWorktreeError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.startsWith("No open tmux window found for worktree: ")) {
+    return { status: 409, error: message };
+  }
+  if (message.startsWith("Worktree not found: ")) {
+    return { status: 404, error: message };
+  }
+  return null;
+}
+
+// backend/src/services/snapshot-service.ts
+function formatElapsedSince(startedAt, now) {
+  if (!startedAt)
+    return "";
+  const startedMs = Date.parse(startedAt);
+  if (Number.isNaN(startedMs))
+    return "";
+  const diffMs = Math.max(0, now().getTime() - startedMs);
+  const diffMinutes = Math.floor(diffMs / 60000);
+  if (diffMinutes < 1)
+    return "0m";
+  if (diffMinutes < 60)
+    return `${diffMinutes}m`;
+  const diffHours = Math.floor(diffMinutes / 60);
+  if (diffHours < 24)
+    return `${diffHours}h`;
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays}d`;
+}
+function clonePrEntry(pr) {
+  return {
+    ...pr,
+    ciChecks: pr.ciChecks.map((check) => ({ ...check })),
+    comments: pr.comments.map((comment) => ({ ...comment }))
+  };
+}
+function mapCreationSnapshot(creating) {
+  return creating ? {
+    phase: creating.phase
+  } : null;
+}
+function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue, findAgentLabel) {
+  return {
+    branch: state.branch,
+    label: state.label,
+    ...state.baseBranch ? { baseBranch: state.baseBranch } : {},
+    path: state.path,
+    dir: state.path,
+    archived: isArchived(state.path),
+    profile: state.profile,
+    agentName: state.agentName,
+    agentLabel: findAgentLabel ? findAgentLabel(state.agentName) : state.agentName,
+    agentTerminalStale: state.agentTerminalStale,
+    mux: state.session.exists,
+    dirty: state.git.dirty,
+    unpushed: state.git.aheadCount > 0,
+    paneCount: state.session.paneCount,
+    status: creating ? "creating" : state.agent.lifecycle,
+    elapsed: formatElapsedSince(state.agent.lastStartedAt, now),
+    services: state.services.map((service) => ({ ...service })),
+    prs: state.prs.map((pr) => clonePrEntry(pr)),
+    linearIssue: findLinearIssue ? findLinearIssue(state.branch) : null,
+    creation: mapCreationSnapshot(creating),
+    source: state.source,
+    oneshot: state.oneshot
+  };
+}
+function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue, findAgentLabel) {
+  return {
+    branch: creating.branch,
+    label: null,
+    ...creating.baseBranch ? { baseBranch: creating.baseBranch } : {},
+    path: creating.path,
+    dir: creating.path,
+    archived: isArchived(creating.path),
+    profile: creating.profile,
+    agentName: creating.agentName,
+    agentLabel: findAgentLabel ? findAgentLabel(creating.agentName) : creating.agentName,
+    agentTerminalStale: false,
+    mux: false,
+    dirty: false,
+    unpushed: false,
+    paneCount: 0,
+    status: "creating",
+    elapsed: "",
+    services: [],
+    prs: [],
+    linearIssue: findLinearIssue ? findLinearIssue(creating.branch) : null,
+    creation: mapCreationSnapshot(creating),
+    source: creating.source,
+    oneshot: null
+  };
+}
+function buildWorktreeSnapshots(input) {
+  const now = input.now ?? (() => new Date);
+  const isArchived = input.isArchived ?? (() => false);
+  const creatingWorktrees = input.creatingWorktrees ?? [];
+  const creatingByBranch = new Map(creatingWorktrees.map((worktree) => [worktree.branch, worktree]));
+  const runtimeWorktrees = input.runtime.listWorktrees();
+  const runtimeBranches = new Set(runtimeWorktrees.map((worktree) => worktree.branch));
+  const worktrees = runtimeWorktrees.map((state) => mapWorktreeSnapshot(state, now, creatingByBranch.get(state.branch) ?? null, isArchived, input.findLinearIssue, input.findAgentLabel));
+  for (const creating of creatingWorktrees) {
+    if (!runtimeBranches.has(creating.branch)) {
+      worktrees.push(mapCreatingWorktreeSnapshot(creating, isArchived, input.findLinearIssue, input.findAgentLabel));
+    }
+  }
+  worktrees.sort((left, right) => left.branch.localeCompare(right.branch));
+  return worktrees;
+}
+function buildProjectSnapshot(input) {
+  return {
+    project: {
+      name: input.projectName,
+      mainBranch: input.mainBranch
+    },
+    worktrees: buildWorktreeSnapshots(input),
+    notifications: input.notifications.map((notification) => ({ ...notification }))
+  };
+}
+
+// backend/src/services/claude-conversation-service.ts
+function isClaudeWorktree(worktree) {
+  return worktree.agentName === "claude";
+}
+function isClaudeConversationMeta(meta) {
+  return meta?.provider === "claudeCode";
+}
+function buildPendingConversationId(worktree) {
+  return `claude-pending:${worktree.path}`;
+}
+function buildClaudeConversationMeta(sessionId, cwd, now) {
+  return {
+    provider: "claudeCode",
+    conversationId: sessionId,
+    sessionId,
+    cwd,
+    lastSeenAt: now.toISOString()
+  };
+}
+function sameConversationMeta2(left, right) {
+  return left?.provider === right.provider && left.conversationId === right.conversationId && left.cwd === right.cwd;
+}
+function normalizeSessionMessages(messages) {
+  return messages.map((message, order) => ({
     ...message,
+    order,
+    kind: message.kind ?? "text",
     status: "completed"
   }));
 }
-function buildConversationState(worktree, session) {
+function buildConversationState2(worktree, session) {
   return {
     provider: "claudeCode",
     conversationId: session?.sessionId ?? buildPendingConversationId(worktree),
@@ -18023,10 +19231,10 @@ function buildConversationState(worktree, session) {
     messages: normalizeSessionMessages(session?.messages ?? [])
   };
 }
-function toWorktreeConversationResponse(worktree, conversationMeta, session) {
+function toWorktreeConversationResponse2(worktree, conversationMeta, session) {
   return {
     worktree: buildAgentsUiWorktreeSummary(worktree, conversationMeta),
-    conversation: buildConversationState(worktree, session)
+    conversation: buildConversationState2(worktree, session)
   };
 }
 
@@ -18042,10 +19250,10 @@ class ClaudeConversationService {
     this.writeMeta = deps.writeMeta ?? writeWorktreeMeta;
   }
   async attachWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, async (resolved) => ok(toWorktreeConversationResponse(worktree, resolved.conversationMeta, resolved.session)));
+    return await this.withResolvedConversation(worktree, async (resolved) => ok(toWorktreeConversationResponse2(worktree, resolved.conversationMeta, resolved.session)));
   }
   async readWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, async (resolved) => ok(toWorktreeConversationResponse(worktree, resolved.conversationMeta, resolved.session)));
+    return await this.withResolvedConversation(worktree, async (resolved) => ok(toWorktreeConversationResponse2(worktree, resolved.conversationMeta, resolved.session)));
   }
   async withResolvedConversation(worktree, fn) {
     if (!isClaudeWorktree(worktree)) {
@@ -18094,7 +19302,7 @@ class ClaudeConversationService {
   }
   async persistConversationMeta(gitDir, meta, cwd, sessionId) {
     const nextConversation = buildClaudeConversationMeta(sessionId, cwd, this.now());
-    if (!sameConversationMeta(meta.conversation, nextConversation)) {
+    if (!sameConversationMeta2(meta.conversation, nextConversation)) {
       await this.writeMeta(gitDir, {
         ...meta,
         conversation: nextConversation
@@ -18104,270 +19312,6 @@ class ClaudeConversationService {
   }
 }
 
-// backend/src/services/worktree-conversation-service.ts
-function resolveCodexAppServerLaunchContext(input) {
-  if (input.worktree.agentName !== "codex" || input.meta.agent !== "codex") {
-    return err(409, "Codex web chat is only available for Codex worktrees");
-  }
-  if (!input.profile) {
-    return err(409, `Profile is missing for Codex web chat: ${input.meta.profile}`);
-  }
-  if (input.meta.runtime !== "host" || input.profile.runtime !== "host") {
-    return err(409, "Codex web chat is only available for host-runtime worktrees. Use the terminal for Docker worktrees.");
-  }
-  if (input.profile.yolo !== true) {
-    return err(409, "Codex web chat requires a yolo profile to preserve the Codex approval policy. Use the terminal for this worktree.");
-  }
-  return ok({
-    approvalPolicy: "never",
-    personality: "pragmatic",
-    sandbox: "danger-full-access"
-  });
-}
-function isCodexWorktree(worktree) {
-  return worktree.agentName === "codex";
-}
-function isCodexConversationMeta(meta) {
-  return meta?.provider === "codexAppServer";
-}
-function toIsoTimestamp(epochSeconds) {
-  if (epochSeconds === null)
-    return null;
-  return new Date(epochSeconds * 1000).toISOString();
-}
-function isUserMessageItem(item) {
-  return item.type === "userMessage";
-}
-function isAgentMessageItem(item) {
-  return item.type === "agentMessage";
-}
-function extractUserText(item) {
-  return item.content.map((contentItem) => contentItem.text ?? "").join("").trim();
-}
-function extractAgentText(item) {
-  return item.text ?? item.message ?? "";
-}
-function isActiveTurnStatus(status) {
-  return status === "inProgress" || status === "active" || status === "running" || status === "pending" || status === "queued";
-}
-function findActiveTurn(thread) {
-  for (let index = thread.turns.length - 1;index >= 0; index -= 1) {
-    const turn = thread.turns[index];
-    if (isActiveTurnStatus(turn.status))
-      return turn;
-  }
-  return null;
-}
-function buildConversationMessages(thread) {
-  const messages = [];
-  for (const turn of thread.turns) {
-    for (const item of turn.items) {
-      if (isUserMessageItem(item)) {
-        const text2 = extractUserText(item);
-        if (text2.length === 0)
-          continue;
-        messages.push({
-          id: item.id,
-          turnId: turn.id,
-          role: "user",
-          text: text2,
-          status: "completed",
-          createdAt: toIsoTimestamp(turn.startedAt)
-        });
-        continue;
-      }
-      if (!isAgentMessageItem(item))
-        continue;
-      const text = extractAgentText(item);
-      if (text.length === 0)
-        continue;
-      messages.push({
-        id: item.id,
-        turnId: turn.id,
-        role: "assistant",
-        text,
-        status: isActiveTurnStatus(turn.status) ? "inProgress" : "completed",
-        createdAt: toIsoTimestamp(turn.completedAt ?? turn.startedAt)
-      });
-    }
-  }
-  return messages;
-}
-function buildConversationState2(thread) {
-  const activeTurn = findActiveTurn(thread);
-  return {
-    provider: "codexAppServer",
-    conversationId: thread.id,
-    cwd: thread.cwd,
-    running: thread.status.type === "active" || activeTurn !== null,
-    activeTurnId: activeTurn?.id ?? null,
-    messages: buildConversationMessages(thread)
-  };
-}
-function selectDiscoveredThread(threads) {
-  if (threads.length === 0)
-    return null;
-  return [...threads].sort((left, right) => right.updatedAt - left.updatedAt)[0] ?? null;
-}
-function buildConversationMeta(thread, now) {
-  return {
-    provider: "codexAppServer",
-    conversationId: thread.id,
-    threadId: thread.id,
-    cwd: thread.cwd,
-    lastSeenAt: now.toISOString()
-  };
-}
-function sameConversationMeta2(left, right) {
-  return left?.provider === right.provider && left.conversationId === right.conversationId && left.cwd === right.cwd;
-}
-function toWorktreeConversationResponse2(worktree, conversationMeta, thread) {
-  return {
-    worktree: buildAgentsUiWorktreeSummary(worktree, conversationMeta),
-    conversation: buildConversationState2(thread)
-  };
-}
-
-class WorktreeConversationService {
-  deps;
-  now;
-  readMeta;
-  writeMeta;
-  constructor(deps) {
-    this.deps = deps;
-    this.now = deps.now ?? (() => new Date);
-    this.readMeta = deps.readMeta ?? readWorktreeMeta;
-    this.writeMeta = deps.writeMeta ?? writeWorktreeMeta;
-  }
-  async attachWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, true, async ({ conversationMeta, thread }) => ok(toWorktreeConversationResponse2(worktree, conversationMeta, thread)));
-  }
-  async readWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, false, async ({ conversationMeta, thread }) => ok(toWorktreeConversationResponse2(worktree, conversationMeta, thread)));
-  }
-  async sendWorktreeConversationMessage(worktree, text) {
-    return await this.withResolvedConversation(worktree, true, async ({ thread, launchContext }) => {
-      const started = await this.deps.appServer.turnStart({
-        threadId: thread.id,
-        cwd: worktree.path,
-        approvalPolicy: launchContext.approvalPolicy,
-        input: [{ type: "text", text }]
-      });
-      return ok({
-        conversationId: thread.id,
-        turnId: started.turn.id,
-        running: true
-      });
-    });
-  }
-  async interruptWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, false, async ({ thread }) => {
-      const conversation = buildConversationState2(thread);
-      const turnId = conversation.activeTurnId;
-      if (!turnId) {
-        return err(409, "No active Codex turn to interrupt");
-      }
-      await this.deps.appServer.turnInterrupt({
-        threadId: thread.id,
-        turnId
-      });
-      return ok({
-        conversationId: thread.id,
-        turnId,
-        interrupted: true
-      });
-    });
-  }
-  async withResolvedConversation(worktree, allowCreate, fn) {
-    if (!isCodexWorktree(worktree)) {
-      return err(409, "Worktree chat is only available for Codex worktrees");
-    }
-    try {
-      const resolved = await this.resolveConversation(worktree, allowCreate);
-      if (!resolved.ok)
-        return resolved;
-      return await fn(resolved.data);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return err(502, message);
-    }
-  }
-  async resolveConversation(worktree, allowCreate) {
-    const gitDir = this.deps.git.resolveWorktreeGitDir(worktree.path);
-    const meta = await this.readMeta(gitDir);
-    if (!meta) {
-      return err(409, "Worktree metadata is missing");
-    }
-    const launchContextResult = await this.deps.resolveLaunchContext({ worktree, meta });
-    if (!launchContextResult.ok)
-      return launchContextResult;
-    const launchContext = launchContextResult.data;
-    const now = this.now();
-    const thread = await this.resolveThread(meta, worktree.path, allowCreate, launchContext);
-    if (!thread) {
-      return err(404, "No Codex thread could be resolved for this worktree");
-    }
-    const conversationMeta = buildConversationMeta(thread, now);
-    const nextMeta = sameConversationMeta2(meta.conversation, conversationMeta) ? { ...meta, conversation: { ...conversationMeta, lastSeenAt: meta.conversation?.lastSeenAt ?? conversationMeta.lastSeenAt } } : { ...meta, conversation: conversationMeta };
-    if (!sameConversationMeta2(meta.conversation, conversationMeta)) {
-      await this.writeMeta(gitDir, nextMeta);
-    }
-    return ok({
-      gitDir,
-      meta: nextMeta,
-      thread,
-      conversationMeta: nextMeta.conversation ?? conversationMeta,
-      launchContext
-    });
-  }
-  async resolveThread(meta, cwd, allowCreate, launchContext) {
-    const discoveredThread = selectDiscoveredThread((await this.deps.appServer.threadList({
-      cwd,
-      limit: 20,
-      sortKey: "updated_at"
-    })).data);
-    if (discoveredThread) {
-      return await this.ensureThreadLoaded(discoveredThread.id, cwd, launchContext);
-    }
-    const savedThreadId = isCodexConversationMeta(meta.conversation) ? meta.conversation.threadId : null;
-    if (savedThreadId) {
-      const savedThread = await this.tryLoadThread(savedThreadId, cwd, launchContext);
-      if (savedThread)
-        return savedThread;
-      log.warn(`[agents] saved codex thread missing, rediscovering cwd=${cwd} threadId=${savedThreadId}`);
-    }
-    if (!allowCreate)
-      return null;
-    const started = await this.deps.appServer.threadStart({
-      cwd,
-      approvalPolicy: launchContext.approvalPolicy,
-      personality: launchContext.personality,
-      sandbox: launchContext.sandbox
-    });
-    return started.thread;
-  }
-  async tryLoadThread(threadId, cwd, launchContext) {
-    try {
-      return await this.ensureThreadLoaded(threadId, cwd, launchContext);
-    } catch {
-      return null;
-    }
-  }
-  async ensureThreadLoaded(threadId, cwd, launchContext) {
-    const initial = await this.deps.appServer.threadRead(threadId, false);
-    if (initial.thread.status.type === "notLoaded") {
-      await this.deps.appServer.threadResume({
-        threadId,
-        cwd,
-        approvalPolicy: launchContext.approvalPolicy,
-        personality: launchContext.personality,
-        sandbox: launchContext.sandbox
-      });
-    }
-    return (await this.deps.appServer.threadRead(threadId, true)).thread;
-  }
-}
-
 // backend/src/domain/events.ts
 function hasBaseFields(raw) {
   return typeof raw.worktreeId === "string" && raw.worktreeId.length > 0 && typeof raw.branch === "string" && raw.branch.length > 0 && typeof raw.type === "string" && ["agent_stopped", "agent_status_changed", "pr_opened", "runtime_error"].includes(raw.type);
@@ -20190,7 +21134,7 @@ async function apiRefreshWorktreeAgentTerminal(branch) {
   await lifecycleService.refreshAgentTerminal(branch);
   return jsonResponse({ ok: true });
 }
-async function loadAgentsConversationSnapshot(branch) {
+async function loadAgentsConversationInitialState(branch) {
   const resolved = await resolveAgentsWorktree(branch);
   if (!resolved.ok) {
     return {
@@ -20221,45 +21165,55 @@ async function readErrorMessage(response) {
   const text = await response.text();
   return text.length > 0 ? text : `HTTP ${response.status}`;
 }
+function nextConversationMessageOrder(messages) {
+  return messages.reduce((order, message) => Math.max(order, message.order + 1), 0);
+}
 async function openAgentsSocket(ws, data) {
-  const snapshot = await loadAgentsConversationSnapshot(data.branch);
-  if (!snapshot.ok) {
-    sendAgentsWs(ws, { type: "error", message: snapshot.message });
-    ws.close(1011, snapshot.message.slice(0, 123));
+  let bufferingNotifications = true;
+  let socketClosed = false;
+  let streamSession = null;
+  const bufferedNotifications = [];
+  const unsubscribeNotifications = codexAppServerClient.onNotification((notification) => {
+    if (bufferingNotifications || !streamSession) {
+      bufferedNotifications.push(notification);
+      return;
+    }
+    const notificationThreadId = readAgentsNotificationThreadId(notification);
+    if (!notificationThreadId || notificationThreadId !== data.conversationId)
+      return;
+    streamSession.handleNotification(notification);
+    data.conversationId = streamSession.currentConversationId();
+  });
+  data.unsubscribe = () => {
+    socketClosed = true;
+    streamSession?.close();
+    unsubscribeNotifications();
+  };
+  const initialState = await loadAgentsConversationInitialState(data.branch);
+  if (socketClosed)
+    return;
+  if (!initialState.ok) {
+    unsubscribeNotifications();
+    sendAgentsWs(ws, { type: "error", message: initialState.message });
+    ws.close(1011, initialState.message.slice(0, 123));
     return;
   }
-  data.conversationId = snapshot.data.conversation.conversationId;
-  sendAgentsWs(ws, {
-    type: "snapshot",
-    data: snapshot.data
+  streamSession = new AgentsConversationStreamSession({
+    conversationId: initialState.data.conversation.conversationId,
+    nextOrder: nextConversationMessageOrder(initialState.data.conversation.messages),
+    send: (event) => sendAgentsWs(ws, event)
   });
-  if (snapshot.data.conversation.provider !== "codexAppServer") {
+  data.conversationId = streamSession.currentConversationId();
+  if (initialState.data.conversation.provider !== "codexAppServer") {
+    unsubscribeNotifications();
+    data.unsubscribe = null;
     return;
   }
-  data.unsubscribe = codexAppServerClient.onNotification((notification) => {
-    const notificationThreadId = readAgentsNotificationThreadId(notification);
-    if (!notificationThreadId || notificationThreadId !== data.conversationId)
-      return;
-    const deltaEvent = buildAgentsUiMessageDeltaEvent(notification);
-    if (deltaEvent) {
-      sendAgentsWs(ws, deltaEvent);
-      return;
-    }
-    if (!shouldRefreshAgentsConversationSnapshot(notification))
-      return;
-    (async () => {
-      const nextSnapshot = await loadAgentsConversationSnapshot(data.branch);
-      if (!nextSnapshot.ok) {
-        sendAgentsWs(ws, { type: "error", message: nextSnapshot.message });
-        return;
-      }
-      data.conversationId = nextSnapshot.data.conversation.conversationId;
-      sendAgentsWs(ws, {
-        type: "snapshot",
-        data: nextSnapshot.data
-      });
-    })();
-  });
+  bufferingNotifications = false;
+  for (const notification of bufferedNotifications) {
+    streamSession.handleNotification(notification);
+    data.conversationId = streamSession.currentConversationId();
+  }
 }
 async function apiRuntimeEvent(req) {
   if (!await hasValidControlToken(req)) {