webmux 0.34.0 → 0.36.0

package/backend/dist/server.js

@@ -6965,7 +6965,7 @@ import { networkInterfaces } from "os";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.34.0",
+  version: "0.36.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -10994,7 +10994,7 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// node_modules/.bun/@ts-rest+core@3.52.1+94e40505b11febf1/node_modules/@ts-rest/core/index.esm.mjs
+// node_modules/.bun/@ts-rest+core@3.52.1+c185e43edea803d3/node_modules/@ts-rest/core/index.esm.mjs
 var isZodObjectStrict = (obj) => {
   return typeof (obj === null || obj === undefined ? undefined : obj.passthrough) === "function";
 };
@@ -11301,6 +11301,15 @@ var LinearIssuesResponseSchema = exports_external.object({
   availability: LinearIssueAvailabilitySchema,
   issues: exports_external.array(LinearIssueSchema)
 });
+var AutoNameProviderSchema = exports_external.enum(["claude", "codex"]);
+var AutoNameConfigResponseSchema = exports_external.object({
+  autoName: exports_external.object({
+    provider: AutoNameProviderSchema,
+    model: exports_external.string().optional(),
+    systemPrompt: exports_external.string().optional()
+  }).nullable(),
+  linearAvailability: LinearIssueAvailabilitySchema
+});
 var WorktreeCreationStateSchema = exports_external.object({
   phase: WorktreeCreationPhaseSchema
 });
@@ -11322,6 +11331,7 @@ var ProjectWorktreeSnapshotSchema = exports_external.object({
   profile: exports_external.string().nullable(),
   agentName: AgentIdSchema.nullable(),
   agentLabel: exports_external.string().nullable(),
+  agentTerminalStale: exports_external.boolean(),
   mux: exports_external.boolean(),
   dirty: exports_external.boolean(),
   unpushed: exports_external.boolean(),
@@ -11370,6 +11380,7 @@ var AgentsUiWorktreeSummarySchema = exports_external.object({
   profile: exports_external.string().nullable(),
   agentName: AgentIdSchema.nullable(),
   agentLabel: exports_external.string().nullable(),
+  agentTerminalStale: exports_external.boolean(),
   mux: exports_external.boolean(),
   status: exports_external.string(),
   dirty: exports_external.boolean(),
@@ -11381,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,
@@ -11415,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({
@@ -11523,6 +11553,7 @@ var apiPaths = {
   removeWorktree: "/api/worktrees/:name",
   openWorktree: "/api/worktrees/:name/open",
   closeWorktree: "/api/worktrees/:name/close",
+  refreshWorktreeAgentTerminal: "/api/worktrees/:name/agent-terminal/refresh",
   setWorktreeArchived: "/api/worktrees/:name/archive",
   syncWorktreePrs: "/api/worktrees/:name/sync-prs",
   postWorktreeToLinear: "/api/worktrees/:name/linear/post",
@@ -11531,6 +11562,7 @@ var apiPaths = {
   mergeWorktree: "/api/worktrees/:name/merge",
   fetchWorktreeDiff: "/api/worktrees/:name/diff",
   fetchLinearIssues: "/api/linear/issues",
+  fetchAutoNameConfig: "/api/project/auto-name",
   setLinearAutoCreate: "/api/linear/auto-create",
   setAutoRemoveOnMerge: "/api/github/auto-remove-on-merge",
   pullMain: "/api/pull-main",
@@ -11721,6 +11753,16 @@ var apiContract = c.router({
       ...commonErrorResponses
     }
   },
+  refreshWorktreeAgentTerminal: {
+    method: "POST",
+    path: apiPaths.refreshWorktreeAgentTerminal,
+    pathParams: WorktreeNameParamsSchema,
+    body: c.noBody(),
+    responses: {
+      200: OkResponseSchema,
+      ...commonErrorResponses
+    }
+  },
   setWorktreeArchived: {
     method: "PUT",
     path: apiPaths.setWorktreeArchived,
@@ -11799,6 +11841,14 @@ var apiContract = c.router({
       502: ErrorResponseSchema
     }
   },
+  fetchAutoNameConfig: {
+    method: "GET",
+    path: apiPaths.fetchAutoNameConfig,
+    responses: {
+      200: AutoNameConfigResponseSchema,
+      500: ErrorResponseSchema
+    }
+  },
   setLinearAutoCreate: {
     method: "PUT",
     path: apiPaths.setLinearAutoCreate,
@@ -12193,10 +12243,237 @@ async function loadControlToken() {
   return controlToken;
 }
 
+// backend/src/adapters/fs.ts
+import { mkdir as mkdir2 } from "fs/promises";
+import { join } from "path";
+
+// backend/src/domain/model.ts
+var WORKTREE_META_SCHEMA_VERSION = 1;
+var WORKTREE_ARCHIVE_STATE_VERSION = 1;
+
+// backend/src/adapters/fs.ts
+var SAFE_ENV_VALUE_RE = /^[A-Za-z0-9_./:@%+=,-]+$/;
+var DOTENV_LINE_RE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)/;
+function stringifyAllocatedPorts(ports) {
+  const entries = Object.entries(ports).map(([key, value]) => [key, String(value)]);
+  return Object.fromEntries(entries);
+}
+function quoteEnvValue(value) {
+  if (value.length > 0 && SAFE_ENV_VALUE_RE.test(value))
+    return value;
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function parseDotenv(content) {
+  const env = {};
+  for (const line of content.split(`
+`)) {
+    if (line.trimStart().startsWith("#"))
+      continue;
+    const match = DOTENV_LINE_RE.exec(line);
+    if (!match)
+      continue;
+    const key = match[1];
+    let value = match[2];
+    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    } else {
+      value = value.trimEnd();
+    }
+    env[key] = value;
+  }
+  return env;
+}
+async function loadDotenvLocal(worktreePath) {
+  try {
+    const content = await Bun.file(join(worktreePath, ".env.local")).text();
+    return parseDotenv(content);
+  } catch {
+    return {};
+  }
+}
+function getWorktreeStoragePaths(gitDir) {
+  const webmuxDir = join(gitDir, "webmux");
+  return {
+    gitDir,
+    webmuxDir,
+    metaPath: join(webmuxDir, "meta.json"),
+    runtimeEnvPath: join(webmuxDir, "runtime.env"),
+    controlEnvPath: join(webmuxDir, "control.env"),
+    prsPath: join(webmuxDir, "prs.json")
+  };
+}
+function getProjectArchiveStatePath(gitDir) {
+  return join(gitDir, "webmux", "archive.json");
+}
+async function ensureWorktreeStorageDirs(gitDir) {
+  const paths = getWorktreeStoragePaths(gitDir);
+  await mkdir2(paths.webmuxDir, { recursive: true });
+  return paths;
+}
+async function readWorktreeMeta(gitDir) {
+  const { metaPath } = getWorktreeStoragePaths(gitDir);
+  try {
+    const raw = await Bun.file(metaPath).json();
+    return normalizeWorktreeMeta(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeWorktreeMeta(gitDir, meta) {
+  const { metaPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(metaPath, JSON.stringify(meta, null, 2) + `
+`);
+}
+function isArchivedWorktreeEntry(raw) {
+  return isRecord(raw) && typeof raw.path === "string" && typeof raw.archivedAt === "string";
+}
+function emptyWorktreeArchiveState() {
+  return {
+    schemaVersion: WORKTREE_ARCHIVE_STATE_VERSION,
+    entries: []
+  };
+}
+function isWorktreeArchiveState(raw) {
+  return isRecord(raw) && typeof raw.schemaVersion === "number" && Array.isArray(raw.entries) && raw.entries.every((entry) => isArchivedWorktreeEntry(entry));
+}
+async function readWorktreeArchiveState(gitDir) {
+  const archivePath = getProjectArchiveStatePath(gitDir);
+  try {
+    const raw = await Bun.file(archivePath).json();
+    return isWorktreeArchiveState(raw) ? {
+      schemaVersion: raw.schemaVersion,
+      entries: raw.entries.map((entry) => ({ ...entry }))
+    } : emptyWorktreeArchiveState();
+  } catch {
+    return emptyWorktreeArchiveState();
+  }
+}
+async function writeWorktreeArchiveState(gitDir, state) {
+  const archivePath = getProjectArchiveStatePath(gitDir);
+  await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(archivePath, JSON.stringify(state, null, 2) + `
+`);
+}
+function buildRuntimeEnvMap(meta, extraEnv = {}, dotenvValues = {}) {
+  return {
+    ...dotenvValues,
+    ...meta.startupEnvValues,
+    ...stringifyAllocatedPorts(meta.allocatedPorts),
+    ...extraEnv,
+    WEBMUX_WORKTREE_ID: meta.worktreeId,
+    WEBMUX_BRANCH: meta.branch,
+    WEBMUX_PROFILE: meta.profile,
+    WEBMUX_AGENT: meta.agent,
+    WEBMUX_RUNTIME: meta.runtime
+  };
+}
+function buildControlEnvMap(input) {
+  return {
+    WEBMUX_CONTROL_URL: input.controlUrl,
+    WEBMUX_CONTROL_TOKEN: input.controlToken,
+    WEBMUX_WORKTREE_ID: input.worktreeId,
+    WEBMUX_BRANCH: input.branch
+  };
+}
+function renderEnvFile(env) {
+  const lines = Object.entries(env).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}=${quoteEnvValue(value)}`);
+  return lines.join(`
+`) + `
+`;
+}
+async function writeRuntimeEnv(gitDir, env) {
+  const { runtimeEnvPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(runtimeEnvPath, renderEnvFile(env));
+}
+async function writeControlEnv(gitDir, env) {
+  const { controlEnvPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(controlEnvPath, renderEnvFile(env));
+}
+function isRecord(raw) {
+  return typeof raw === "object" && raw !== null && !Array.isArray(raw);
+}
+function normalizeConversationMeta(raw) {
+  if (!raw)
+    return raw;
+  if (raw.provider === "codexAppServer") {
+    const conversationId2 = raw.conversationId || raw.threadId;
+    const threadId = raw.threadId || raw.conversationId;
+    if (!conversationId2 || !threadId)
+      return;
+    const normalized2 = {
+      provider: "codexAppServer",
+      conversationId: conversationId2,
+      threadId,
+      cwd: raw.cwd,
+      lastSeenAt: raw.lastSeenAt
+    };
+    return normalized2;
+  }
+  const conversationId = raw.conversationId || raw.sessionId;
+  const sessionId = raw.sessionId || raw.conversationId;
+  if (!conversationId || !sessionId)
+    return;
+  const normalized = {
+    provider: "claudeCode",
+    conversationId,
+    sessionId,
+    cwd: raw.cwd,
+    lastSeenAt: raw.lastSeenAt
+  };
+  return normalized;
+}
+function normalizeOptionalString(raw) {
+  return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
+}
+function normalizeWorktreeMeta(meta) {
+  const conversation = normalizeConversationMeta(meta.conversation);
+  const normalizedLabel = normalizeOptionalString(meta.label);
+  if (conversation === meta.conversation && normalizedLabel === meta.label) {
+    return meta;
+  }
+  const rest = { ...meta };
+  delete rest.label;
+  delete rest.conversation;
+  return {
+    ...rest,
+    ...normalizedLabel ? { label: normalizedLabel } : {},
+    ...conversation !== undefined ? { conversation } : {}
+  };
+}
+function isPrComment(raw) {
+  if (!isRecord(raw))
+    return false;
+  return (raw.type === "comment" || raw.type === "inline") && typeof raw.author === "string" && typeof raw.body === "string" && typeof raw.createdAt === "string" && (raw.path === undefined || typeof raw.path === "string") && (raw.line === undefined || raw.line === null || typeof raw.line === "number") && (raw.diffHunk === undefined || typeof raw.diffHunk === "string") && (raw.isReply === undefined || typeof raw.isReply === "boolean");
+}
+function isCiCheck(raw) {
+  if (!isRecord(raw))
+    return false;
+  return typeof raw.name === "string" && (raw.status === "pending" || raw.status === "success" || raw.status === "failed" || raw.status === "skipped") && (raw.url === null || typeof raw.url === "string") && (raw.runId === null || typeof raw.runId === "number");
+}
+function isPrEntry(raw) {
+  if (!isRecord(raw))
+    return false;
+  return typeof raw.repo === "string" && typeof raw.number === "number" && (raw.state === "open" || raw.state === "closed" || raw.state === "merged") && typeof raw.url === "string" && typeof raw.updatedAt === "string" && (raw.ciStatus === "none" || raw.ciStatus === "pending" || raw.ciStatus === "success" || raw.ciStatus === "failed") && Array.isArray(raw.ciChecks) && raw.ciChecks.every((check) => isCiCheck(check)) && Array.isArray(raw.comments) && raw.comments.every((comment) => isPrComment(comment));
+}
+async function readWorktreePrs(gitDir) {
+  const { prsPath } = getWorktreeStoragePaths(gitDir);
+  try {
+    const raw = await Bun.file(prsPath).json();
+    return Array.isArray(raw) && raw.every((entry) => isPrEntry(entry)) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+async function writeWorktreePrs(gitDir, prs) {
+  const { prsPath } = await ensureWorktreeStorageDirs(gitDir);
+  await Bun.write(prsPath, JSON.stringify(prs, null, 2) + `
+`);
+}
+
 // backend/src/adapters/claude-cli.ts
 import { readdir, stat } from "fs/promises";
-import { basename, join } from "path";
-function isRecord(raw) {
+import { basename, join as join2 } from "path";
+function isRecord2(raw) {
   return typeof raw === "object" && raw !== null && !Array.isArray(raw);
 }
 function readString(raw) {
@@ -12221,7 +12498,7 @@ function extractToolResultText(content) {
   if (!Array.isArray(content))
     return truncate(compactJson(content));
   const text = content.map((entry) => {
-    if (!isRecord(entry))
+    if (!isRecord2(entry))
       return "";
     if (entry.type === "text" && typeof entry.text === "string")
       return entry.text;
@@ -12230,17 +12507,17 @@ function extractToolResultText(content) {
   return truncate(text);
 }
 function isTopLevelClaudeUserPrompt(raw) {
-  if (raw.type !== "user" || !isRecord(raw.message))
+  if (raw.type !== "user" || !isRecord2(raw.message))
     return false;
   return raw.message.role === "user" && typeof raw.message.content === "string" && typeof raw.uuid === "string" && raw.message.content.trim().length > 0;
 }
 function isClaudeUserToolResultRecord(raw) {
-  if (raw.type !== "user" || !isRecord(raw.message))
+  if (raw.type !== "user" || !isRecord2(raw.message))
     return false;
   return raw.message.role === "user" && Array.isArray(raw.message.content) && typeof raw.uuid === "string";
 }
 function isClaudeAssistantRecord(raw) {
-  if (raw.type !== "assistant" || !isRecord(raw.message))
+  if (raw.type !== "assistant" || !isRecord2(raw.message))
     return false;
   return raw.message.role === "assistant" && typeof raw.uuid === "string";
 }
@@ -12252,19 +12529,19 @@ function readClaudeProjectsRoot() {
   if (!home) {
     throw new Error("HOME is required to resolve Claude sessions");
   }
-  return join(home, ".claude", "projects");
+  return join2(home, ".claude", "projects");
 }
 async function listJsonlFiles(dir) {
   try {
     const entries = await readdir(dir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => join(dir, entry.name));
+    return entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => join2(dir, entry.name));
   } catch {
     return [];
   }
 }
 async function findClaudeSessionPath(sessionId, cwd) {
   const projectsRoot = readClaudeProjectsRoot();
-  const primaryPath = join(projectsRoot, encodeClaudeProjectDir(cwd), `${sessionId}.jsonl`);
+  const primaryPath = join2(projectsRoot, encodeClaudeProjectDir(cwd), `${sessionId}.jsonl`);
   try {
     await stat(primaryPath);
     return primaryPath;
@@ -12273,7 +12550,7 @@ async function findClaudeSessionPath(sessionId, cwd) {
   for (const entry of projectDirs) {
     if (!entry.isDirectory())
       continue;
-    const candidate = join(projectsRoot, entry.name, `${sessionId}.jsonl`);
+    const candidate = join2(projectsRoot, entry.name, `${sessionId}.jsonl`);
     try {
       await stat(candidate);
       return candidate;
@@ -12331,7 +12608,7 @@ function buildClaudeSessionFromText(input) {
       continue;
     if (isClaudeUserToolResultRecord(record)) {
       for (const entry of record.message.content) {
-        if (!isRecord(entry) || entry.type !== "tool_result")
+        if (!isRecord2(entry) || entry.type !== "tool_result")
           continue;
         const text = extractToolResultText(entry.content);
         if (text.length === 0)
@@ -12352,7 +12629,7 @@ function buildClaudeSessionFromText(input) {
     if (!Array.isArray(record.message.content))
       continue;
     for (const block of record.message.content) {
-      if (!isRecord(block))
+      if (!isRecord2(block))
         continue;
       if (block.type === "text" && typeof block.text === "string") {
         const text = block.text.trim();
@@ -12398,7 +12675,7 @@ function buildClaudeSessionFromText(input) {
 class ClaudeCliClient {
   async listSessions(cwd) {
     const projectsRoot = readClaudeProjectsRoot();
-    const primaryDir = join(projectsRoot, encodeClaudeProjectDir(cwd));
+    const primaryDir = join2(projectsRoot, encodeClaudeProjectDir(cwd));
     const primaryFiles = await listJsonlFiles(primaryDir);
     if (primaryFiles.length > 0) {
       return await this.summarizeSessionFiles(primaryFiles, cwd);
@@ -12408,7 +12685,7 @@ class ClaudeCliClient {
     for (const entry of projectDirs) {
       if (!entry.isDirectory())
         continue;
-      const files = await listJsonlFiles(join(projectsRoot, entry.name));
+      const files = await listJsonlFiles(join2(projectsRoot, entry.name));
       for (const filePath of files) {
         const session = await this.readSessionFile(filePath);
         if (session?.cwd === cwd) {
@@ -12547,15 +12824,15 @@ class ClaudeCliClient {
       log.warn(`[agents] failed to parse Claude stream line: ${line.slice(0, 120)}`);
       return;
     }
-    if (!isRecord(parsed))
+    if (!isRecord2(parsed))
       return;
     const sessionId = readString(parsed.session_id);
     if (sessionId) {
       resolveSessionId(sessionId);
     }
-    if (parsed.type === "stream_event" && isRecord(parsed.event)) {
+    if (parsed.type === "stream_event" && isRecord2(parsed.event)) {
       const event = parsed.event;
-      if (event.type === "content_block_delta" && isRecord(event.delta) && event.delta.type === "text_delta") {
+      if (event.type === "content_block_delta" && isRecord2(event.delta) && event.delta.type === "text_delta") {
         const delta = readString(event.delta.text);
         if (delta) {
           callbacks.onAssistantDelta?.(delta);
@@ -12581,7 +12858,7 @@ class ClaudeCliClient {
 }
 
 // backend/src/lib/type-guards.ts
-function isRecord2(raw) {
+function isRecord3(raw) {
   return typeof raw === "object" && raw !== null && !Array.isArray(raw);
 }
 function isStringArray(raw) {
@@ -12591,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()
@@ -12603,26 +12888,121 @@ var CodexAppServerUserMessageItemSchema = exports_external.object({
 var CodexAppServerAgentMessageItemSchema = exports_external.object({
   type: exports_external.literal("agentMessage"),
   id: exports_external.string(),
-  text: exports_external.string(),
-  phase: exports_external.string(),
-  memoryCitation: UnknownValueSchema
-}).transform((value) => ({
-  type: value.type,
-  id: value.id,
-  text: value.text,
-  phase: value.phase,
-  memoryCitation: value.memoryCitation
-}));
-var CodexAppServerGenericItemSchema = exports_external.object({
+  text: exports_external.string().optional(),
+  message: exports_external.string().optional(),
+  phase: exports_external.string().nullable().optional(),
+  memoryCitation: UnknownValueSchema.optional()
+});
+var CodexAppServerCommandActionSchema = exports_external.object({
   type: exports_external.string(),
-  id: exports_external.string()
+  command: exports_external.string().optional(),
+  path: exports_external.string().nullable().optional()
 });
-var CodexAppServerThreadItemSchema = exports_external.union([
-  CodexAppServerUserMessageItemSchema,
-  CodexAppServerAgentMessageItemSchema,
-  CodexAppServerGenericItemSchema
+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 CodexAppServerTurnSchema = exports_external.object({
+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()
+});
+var CodexAppServerThreadItemSchema = exports_external.union([
+  CodexAppServerUserMessageItemSchema,
+  CodexAppServerAgentMessageItemSchema,
+  CodexAppServerCommandExecutionItemSchema,
+  CodexAppServerFileChangeItemSchema,
+  CodexAppServerMcpToolCallItemSchema,
+  CodexAppServerDynamicToolCallItemSchema,
+  CodexAppServerWebSearchItemSchema,
+  CodexAppServerIgnoredItemSchema,
+  CodexAppServerGenericItemSchema
+]);
+var CodexAppServerTurnSchema = exports_external.object({
   id: exports_external.string(),
   items: exports_external.array(CodexAppServerThreadItemSchema),
   status: exports_external.string(),
@@ -12709,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;
@@ -12723,7 +13127,6 @@ class CodexAppServerRequestError extends Error {
 class CodexAppServerClient {
   opts;
   encoder = new TextEncoder;
-  decoder = new TextDecoder;
   listeners = new Set;
   pending = new Map;
   nextId = 1;
@@ -12810,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);
@@ -12839,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}`);
           }
@@ -12864,7 +13273,7 @@ class CodexAppServerClient {
       log.error(`[agents] failed to parse codex app-server line: ${line}`, error);
       return;
     }
-    if (!isRecord2(parsed)) {
+    if (!isRecord3(parsed)) {
       log.warn(`[agents] unexpected codex app-server payload: ${line}`);
       return;
     }
@@ -12952,7 +13361,7 @@ class CodexAppServerClient {
     this.readyPromise = null;
   }
   readResponseError(raw) {
-    if (!isRecord2(raw.error))
+    if (!isRecord3(raw.error))
       return null;
     return typeof raw.error.code === "number" && typeof raw.error.message === "string" ? {
       code: raw.error.code,
@@ -12964,7 +13373,7 @@ class CodexAppServerClient {
 
 // backend/src/adapters/config.ts
 import { readFileSync } from "fs";
-import { dirname as dirname2, join as join2, resolve } from "path";
+import { dirname as dirname2, join as join3, resolve } from "path";
 
 // node_modules/.bun/yaml@2.9.0/node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -13072,7 +13481,7 @@ function cloneProfiles(profiles) {
 function defaultProfiles() {
   return { default: cloneProfile(DEFAULT_CONFIG.profiles.default) };
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isStringArray2(value) {
@@ -13088,7 +13497,7 @@ function parsePanes(raw) {
   return panes.length > 0 ? panes : clonePanes(DEFAULT_PANES);
 }
 function parsePane(raw, index) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return null;
   if (raw.kind !== "agent" && raw.kind !== "shell" && raw.kind !== "command")
     return null;
@@ -13117,7 +13526,7 @@ function parsePane(raw, index) {
 function parseMounts(raw) {
   if (!Array.isArray(raw))
     return;
-  const mounts = raw.filter(isRecord3).filter((entry) => typeof entry.hostPath === "string" && entry.hostPath.length > 0).map((entry) => ({
+  const mounts = raw.filter(isRecord4).filter((entry) => typeof entry.hostPath === "string" && entry.hostPath.length > 0).map((entry) => ({
     hostPath: entry.hostPath,
     ...typeof entry.guestPath === "string" && entry.guestPath.length > 0 ? { guestPath: entry.guestPath } : {},
     ...typeof entry.writable === "boolean" ? { writable: entry.writable } : {}
@@ -13125,7 +13534,7 @@ function parseMounts(raw) {
   return mounts.length > 0 ? mounts : undefined;
 }
 function parseProfile(raw, fallbackRuntime) {
-  if (!isRecord3(raw)) {
+  if (!isRecord4(raw)) {
     return {
       runtime: fallbackRuntime,
       envPassthrough: [],
@@ -13148,7 +13557,7 @@ function parseProfile(raw, fallbackRuntime) {
   };
 }
 function parseProfiles(raw, includeDefaultProfile) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return includeDefaultProfile ? defaultProfiles() : {};
   const profiles = Object.entries(raw).reduce((acc, [name, value]) => {
     const fallbackRuntime = name === "sandbox" ? "docker" : "host";
@@ -13167,7 +13576,7 @@ function cloneAgents(agents) {
   return Object.fromEntries(Object.entries(agents).map(([id, agent]) => [id, cloneAgentConfig(agent)]));
 }
 function parseCustomAgent(raw) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return null;
   if (typeof raw.label !== "string" || !raw.label.trim())
     return null;
@@ -13180,7 +13589,7 @@ function parseCustomAgent(raw) {
   };
 }
 function parseCustomAgents(raw) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return {};
   return Object.entries(raw).reduce((acc, [id, value]) => {
     if (!id.trim())
@@ -13195,7 +13604,7 @@ function parseCustomAgents(raw) {
 function parseServices(raw) {
   if (!Array.isArray(raw))
     return [];
-  return raw.filter(isRecord3).filter((entry) => typeof entry.name === "string" && typeof entry.portEnv === "string").map((entry) => ({
+  return raw.filter(isRecord4).filter((entry) => typeof entry.name === "string" && typeof entry.portEnv === "string").map((entry) => ({
     name: entry.name,
     portEnv: entry.portEnv,
     ...typeof entry.portStart === "number" && Number.isFinite(entry.portStart) ? { portStart: entry.portStart } : {},
@@ -13204,7 +13613,7 @@ function parseServices(raw) {
   }));
 }
 function parseStartupEnvs(raw) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return {};
   const startupEnvs = {};
   for (const [key, value] of Object.entries(raw)) {
@@ -13217,7 +13626,7 @@ function parseStartupEnvs(raw) {
   return startupEnvs;
 }
 function parseLifecycleHooks(raw) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return {};
   const hooks = {};
   if (typeof raw.postCreate === "string" && raw.postCreate.trim()) {
@@ -13229,13 +13638,13 @@ function parseLifecycleHooks(raw) {
   return hooks;
 }
 function parseOneshot(raw) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return { systemPrompt: DEFAULT_ONESHOT_SYSTEM_PROMPT() };
   const systemPrompt = typeof raw.systemPrompt === "string" && raw.systemPrompt.trim() ? raw.systemPrompt.trim() : DEFAULT_ONESHOT_SYSTEM_PROMPT();
   return { systemPrompt };
 }
 function parseAutoName(raw) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return null;
   const provider = raw.provider;
   if (provider !== "claude" && provider !== "codex")
@@ -13247,7 +13656,7 @@ function parseAutoName(raw) {
   };
 }
 function parseAutoPull(raw) {
-  if (!isRecord3(raw))
+  if (!isRecord4(raw))
     return DEFAULT_CONFIG.workspace.autoPull;
   const enabled = typeof raw.enabled === "boolean" ? raw.enabled : false;
   const interval = typeof raw.intervalSeconds === "number" && Number.isFinite(raw.intervalSeconds) && raw.intervalSeconds >= 30 ? raw.intervalSeconds : 300;
@@ -13256,7 +13665,7 @@ function parseAutoPull(raw) {
 function parseLinkedRepos(raw) {
   if (!Array.isArray(raw))
     return [];
-  return raw.filter(isRecord3).filter((entry) => typeof entry.repo === "string").map((entry) => ({
+  return raw.filter(isRecord4).filter((entry) => typeof entry.repo === "string").map((entry) => ({
     repo: entry.repo,
     alias: typeof entry.alias === "string" ? entry.alias : entry.repo.split("/").pop() ?? "repo",
     ...typeof entry.dir === "string" && entry.dir.trim() ? { dir: entry.dir.trim() } : {}
@@ -13271,23 +13680,23 @@ function getDefaultProfileName(config) {
   return Object.keys(config.profiles)[0] ?? "default";
 }
 function readConfigFile(root) {
-  return readFileSync(join2(root, ".webmux.yaml"), "utf8");
+  return readFileSync(join3(root, ".webmux.yaml"), "utf8");
 }
 function readLocalConfigFile(root) {
-  return readFileSync(join2(root, ".webmux.local.yaml"), "utf8");
+  return readFileSync(join3(root, ".webmux.local.yaml"), "utf8");
 }
 function parseConfigDocument(text) {
   const parsed = $parse(text);
-  return isRecord3(parsed) ? parsed : {};
+  return isRecord4(parsed) ? parsed : {};
 }
 function parseProjectConfig(parsed) {
   return {
     name: typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : DEFAULT_CONFIG.name,
     workspace: {
-      mainBranch: isRecord3(parsed.workspace) && typeof parsed.workspace.mainBranch === "string" ? parsed.workspace.mainBranch : DEFAULT_CONFIG.workspace.mainBranch,
-      worktreeRoot: isRecord3(parsed.workspace) && typeof parsed.workspace.worktreeRoot === "string" ? parsed.workspace.worktreeRoot : DEFAULT_CONFIG.workspace.worktreeRoot,
-      defaultAgent: isRecord3(parsed.workspace) ? parseAgentKind(parsed.workspace.defaultAgent) : DEFAULT_CONFIG.workspace.defaultAgent,
-      autoPull: isRecord3(parsed.workspace) ? parseAutoPull(parsed.workspace.autoPull) : DEFAULT_CONFIG.workspace.autoPull
+      mainBranch: isRecord4(parsed.workspace) && typeof parsed.workspace.mainBranch === "string" ? parsed.workspace.mainBranch : DEFAULT_CONFIG.workspace.mainBranch,
+      worktreeRoot: isRecord4(parsed.workspace) && typeof parsed.workspace.worktreeRoot === "string" ? parsed.workspace.worktreeRoot : DEFAULT_CONFIG.workspace.worktreeRoot,
+      defaultAgent: isRecord4(parsed.workspace) ? parseAgentKind(parsed.workspace.defaultAgent) : DEFAULT_CONFIG.workspace.defaultAgent,
+      autoPull: isRecord4(parsed.workspace) ? parseAutoPull(parsed.workspace.autoPull) : DEFAULT_CONFIG.workspace.autoPull
     },
     profiles: parseProfiles(parsed.profiles, true),
     agents: {},
@@ -13295,8 +13704,8 @@ function parseProjectConfig(parsed) {
     startupEnvs: parseStartupEnvs(parsed.startupEnvs),
     integrations: {
       github: {
-        linkedRepos: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : isRecord3(parsed.integrations) && Array.isArray(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github) : [],
-        autoRemoveOnMerge: isRecord3(parsed.integrations) && isRecord3(parsed.integrations.github) && typeof parsed.integrations.github.autoRemoveOnMerge === "boolean" ? parsed.integrations.github.autoRemoveOnMerge : DEFAULT_CONFIG.integrations.github.autoRemoveOnMerge
+        linkedRepos: isRecord4(parsed.integrations) && isRecord4(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github.linkedRepos) : isRecord4(parsed.integrations) && Array.isArray(parsed.integrations.github) ? parseLinkedRepos(parsed.integrations.github) : [],
+        autoRemoveOnMerge: isRecord4(parsed.integrations) && isRecord4(parsed.integrations.github) && typeof parsed.integrations.github.autoRemoveOnMerge === "boolean" ? parsed.integrations.github.autoRemoveOnMerge : DEFAULT_CONFIG.integrations.github.autoRemoveOnMerge
       },
       linear: parseLinearIntegration(parsed)
     },
@@ -13317,7 +13726,7 @@ function parseTeamKeyList(raw) {
 var warnedLegacyLinearTeamId = false;
 function parseLinearIntegration(parsed) {
   const defaults = DEFAULT_CONFIG.integrations.linear;
-  const linear = isRecord3(parsed.integrations) && isRecord3(parsed.integrations.linear) ? parsed.integrations.linear : null;
+  const linear = isRecord4(parsed.integrations) && isRecord4(parsed.integrations.linear) ? parsed.integrations.linear : null;
   if (!linear)
     return { ...defaults };
   if (typeof linear.teamId === "string" && !warnedLegacyLinearTeamId) {
@@ -13333,10 +13742,10 @@ function parseLinearIntegration(parsed) {
   };
 }
 function parseLocalLinearOverlay(parsed) {
-  if (!isRecord3(parsed.integrations))
+  if (!isRecord4(parsed.integrations))
     return null;
   const linear = parsed.integrations.linear;
-  if (!isRecord3(linear))
+  if (!isRecord4(linear))
     return null;
   const overlay = {};
   if (typeof linear.enabled === "boolean")
@@ -13351,10 +13760,10 @@ function parseLocalLinearOverlay(parsed) {
   return Object.keys(overlay).length > 0 ? overlay : null;
 }
 function parseLocalGitHubOverlay(parsed) {
-  if (!isRecord3(parsed.integrations))
+  if (!isRecord4(parsed.integrations))
     return null;
   const github = parsed.integrations.github;
-  if (!isRecord3(github))
+  if (!isRecord4(github))
     return null;
   const overlay = {};
   if (typeof github.autoRemoveOnMerge === "boolean")
@@ -13362,10 +13771,10 @@ function parseLocalGitHubOverlay(parsed) {
   return Object.keys(overlay).length > 0 ? overlay : null;
 }
 function parseLocalAutoPullOverlay(parsed) {
-  if (!isRecord3(parsed.workspace))
+  if (!isRecord4(parsed.workspace))
     return null;
   const autoPull = parsed.workspace.autoPull;
-  if (!isRecord3(autoPull))
+  if (!isRecord4(autoPull))
     return null;
   const overlay = {};
   if (typeof autoPull.enabled === "boolean")
@@ -13382,7 +13791,7 @@ function loadLocalProjectConfigOverlay(root) {
       return { worktreeRoot: null, profiles: {}, agents: {}, lifecycleHooks: {}, linear: null, github: null, autoPull: null };
     }
     const parsed = parseConfigDocument(text);
-    const ws = isRecord3(parsed.workspace) ? parsed.workspace : null;
+    const ws = isRecord4(parsed.workspace) ? parsed.workspace : null;
     return {
       worktreeRoot: ws && typeof ws.worktreeRoot === "string" ? ws.worktreeRoot : null,
       profiles: parseProfiles(parsed.profiles, false),
@@ -13462,7 +13871,7 @@ function loadConfig(dir, options = {}) {
   };
 }
 function readLocalConfigDocument(root) {
-  const localPath = join2(root, ".webmux.local.yaml");
+  const localPath = join3(root, ".webmux.local.yaml");
   let existing = {};
   try {
     const text = readFileSync(localPath, "utf8").trim();
@@ -13474,8 +13883,8 @@ function readLocalConfigDocument(root) {
 async function persistLocalLinearConfig(dir, changes) {
   const root = projectRoot(dir);
   const { localPath, existing } = readLocalConfigDocument(root);
-  const integrations = isRecord3(existing.integrations) ? { ...existing.integrations } : {};
-  const linear = isRecord3(integrations.linear) ? { ...integrations.linear } : {};
+  const integrations = isRecord4(existing.integrations) ? { ...existing.integrations } : {};
+  const linear = isRecord4(integrations.linear) ? { ...integrations.linear } : {};
   Object.assign(linear, changes);
   integrations.linear = linear;
   existing.integrations = integrations;
@@ -13484,8 +13893,8 @@ async function persistLocalLinearConfig(dir, changes) {
 async function persistLocalGitHubConfig(dir, changes) {
   const root = projectRoot(dir);
   const { localPath, existing } = readLocalConfigDocument(root);
-  const integrations = isRecord3(existing.integrations) ? { ...existing.integrations } : {};
-  const github = isRecord3(integrations.github) ? { ...integrations.github } : {};
+  const integrations = isRecord4(existing.integrations) ? { ...existing.integrations } : {};
+  const github = isRecord4(integrations.github) ? { ...integrations.github } : {};
   Object.assign(github, changes);
   integrations.github = github;
   existing.integrations = integrations;
@@ -13494,7 +13903,7 @@ async function persistLocalGitHubConfig(dir, changes) {
 async function persistLocalCustomAgent(dir, agentId, agent) {
   const root = projectRoot(dir);
   const { localPath, existing } = readLocalConfigDocument(root);
-  const agents = isRecord3(existing.agents) ? { ...existing.agents } : {};
+  const agents = isRecord4(existing.agents) ? { ...existing.agents } : {};
   agents[agentId] = {
     label: agent.label,
     startCommand: agent.startCommand,
@@ -13506,7 +13915,7 @@ async function persistLocalCustomAgent(dir, agentId, agent) {
 async function removeLocalCustomAgent(dir, agentId) {
   const root = projectRoot(dir);
   const { localPath, existing } = readLocalConfigDocument(root);
-  if (!isRecord3(existing.agents) || !(agentId in existing.agents)) {
+  if (!isRecord4(existing.agents) || !(agentId in existing.agents)) {
     return;
   }
   const agents = { ...existing.agents };
@@ -13615,12 +14024,6 @@ function hasRecentDashboardActivity() {
 
 // backend/src/services/archive-service.ts
 import { resolve as resolve2 } from "path";
-
-// backend/src/domain/model.ts
-var WORKTREE_META_SCHEMA_VERSION = 1;
-var WORKTREE_ARCHIVE_STATE_VERSION = 1;
-
-// backend/src/services/archive-service.ts
 function createArchiveState(entries) {
   return {
     schemaVersion: WORKTREE_ARCHIVE_STATE_VERSION,
@@ -14300,6 +14703,14 @@ function findLinkedGitHubPr(issue) {
   });
   return indexed[0].pr;
 }
+function buildLinearPickupMarkdown(input) {
+  return [
+    `**Webmux pickup \u2014 branch \`${input.branch}\`**`,
+    "",
+    `- Picked up: ${input.pickedUpAt.toISOString()}`
+  ].join(`
+`);
+}
 function buildLinearSummaryMarkdown(input) {
   const lines = [
     `**Webmux session \u2014 branch \`${input.branch}\`**`,
@@ -14472,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
@@ -14656,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 };
@@ -14674,235 +15097,12 @@ import { dirname as dirname4, resolve as resolve7 } from "path";
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
 import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
-
-// backend/src/adapters/fs.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
-var SAFE_ENV_VALUE_RE = /^[A-Za-z0-9_./:@%+=,-]+$/;
-var DOTENV_LINE_RE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)/;
-function stringifyAllocatedPorts(ports) {
-  const entries = Object.entries(ports).map(([key, value]) => [key, String(value)]);
-  return Object.fromEntries(entries);
-}
-function quoteEnvValue(value) {
-  if (value.length > 0 && SAFE_ENV_VALUE_RE.test(value))
-    return value;
+var GENERATED_CODEX_HOOKS_EXCLUDE = ".codex/hooks.json";
+function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
-function parseDotenv(content) {
-  const env = {};
-  for (const line of content.split(`
-`)) {
-    if (line.trimStart().startsWith("#"))
-      continue;
-    const match = DOTENV_LINE_RE.exec(line);
-    if (!match)
-      continue;
-    const key = match[1];
-    let value = match[2];
-    if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1);
-    } else {
-      value = value.trimEnd();
-    }
-    env[key] = value;
-  }
-  return env;
-}
-async function loadDotenvLocal(worktreePath) {
-  try {
-    const content = await Bun.file(join3(worktreePath, ".env.local")).text();
-    return parseDotenv(content);
-  } catch {
-    return {};
-  }
-}
-function getWorktreeStoragePaths(gitDir) {
-  const webmuxDir = join3(gitDir, "webmux");
-  return {
-    gitDir,
-    webmuxDir,
-    metaPath: join3(webmuxDir, "meta.json"),
-    runtimeEnvPath: join3(webmuxDir, "runtime.env"),
-    controlEnvPath: join3(webmuxDir, "control.env"),
-    prsPath: join3(webmuxDir, "prs.json")
-  };
-}
-function getProjectArchiveStatePath(gitDir) {
-  return join3(gitDir, "webmux", "archive.json");
-}
-async function ensureWorktreeStorageDirs(gitDir) {
-  const paths = getWorktreeStoragePaths(gitDir);
-  await mkdir2(paths.webmuxDir, { recursive: true });
-  return paths;
-}
-async function readWorktreeMeta(gitDir) {
-  const { metaPath } = getWorktreeStoragePaths(gitDir);
-  try {
-    const raw = await Bun.file(metaPath).json();
-    return normalizeWorktreeMeta(raw);
-  } catch {
-    return null;
-  }
-}
-async function writeWorktreeMeta(gitDir, meta) {
-  const { metaPath } = await ensureWorktreeStorageDirs(gitDir);
-  await Bun.write(metaPath, JSON.stringify(meta, null, 2) + `
-`);
-}
-function isArchivedWorktreeEntry(raw) {
-  return isRecord4(raw) && typeof raw.path === "string" && typeof raw.archivedAt === "string";
-}
-function emptyWorktreeArchiveState() {
-  return {
-    schemaVersion: WORKTREE_ARCHIVE_STATE_VERSION,
-    entries: []
-  };
-}
-function isWorktreeArchiveState(raw) {
-  return isRecord4(raw) && typeof raw.schemaVersion === "number" && Array.isArray(raw.entries) && raw.entries.every((entry) => isArchivedWorktreeEntry(entry));
-}
-async function readWorktreeArchiveState(gitDir) {
-  const archivePath = getProjectArchiveStatePath(gitDir);
-  try {
-    const raw = await Bun.file(archivePath).json();
-    return isWorktreeArchiveState(raw) ? {
-      schemaVersion: raw.schemaVersion,
-      entries: raw.entries.map((entry) => ({ ...entry }))
-    } : emptyWorktreeArchiveState();
-  } catch {
-    return emptyWorktreeArchiveState();
-  }
-}
-async function writeWorktreeArchiveState(gitDir, state) {
-  const archivePath = getProjectArchiveStatePath(gitDir);
-  await ensureWorktreeStorageDirs(gitDir);
-  await Bun.write(archivePath, JSON.stringify(state, null, 2) + `
-`);
-}
-function buildRuntimeEnvMap(meta, extraEnv = {}, dotenvValues = {}) {
-  return {
-    ...dotenvValues,
-    ...meta.startupEnvValues,
-    ...stringifyAllocatedPorts(meta.allocatedPorts),
-    ...extraEnv,
-    WEBMUX_WORKTREE_ID: meta.worktreeId,
-    WEBMUX_BRANCH: meta.branch,
-    WEBMUX_PROFILE: meta.profile,
-    WEBMUX_AGENT: meta.agent,
-    WEBMUX_RUNTIME: meta.runtime
-  };
-}
-function buildControlEnvMap(input) {
-  return {
-    WEBMUX_CONTROL_URL: input.controlUrl,
-    WEBMUX_CONTROL_TOKEN: input.controlToken,
-    WEBMUX_WORKTREE_ID: input.worktreeId,
-    WEBMUX_BRANCH: input.branch
-  };
-}
-function renderEnvFile(env) {
-  const lines = Object.entries(env).sort(([a], [b]) => a.localeCompare(b)).map(([key, value]) => `${key}=${quoteEnvValue(value)}`);
-  return lines.join(`
-`) + `
-`;
-}
-async function writeRuntimeEnv(gitDir, env) {
-  const { runtimeEnvPath } = await ensureWorktreeStorageDirs(gitDir);
-  await Bun.write(runtimeEnvPath, renderEnvFile(env));
-}
-async function writeControlEnv(gitDir, env) {
-  const { controlEnvPath } = await ensureWorktreeStorageDirs(gitDir);
-  await Bun.write(controlEnvPath, renderEnvFile(env));
-}
-function isRecord4(raw) {
-  return typeof raw === "object" && raw !== null && !Array.isArray(raw);
-}
-function normalizeConversationMeta(raw) {
-  if (!raw)
-    return raw;
-  if (raw.provider === "codexAppServer") {
-    const conversationId2 = raw.conversationId || raw.threadId;
-    const threadId = raw.threadId || raw.conversationId;
-    if (!conversationId2 || !threadId)
-      return;
-    const normalized2 = {
-      provider: "codexAppServer",
-      conversationId: conversationId2,
-      threadId,
-      cwd: raw.cwd,
-      lastSeenAt: raw.lastSeenAt
-    };
-    return normalized2;
-  }
-  const conversationId = raw.conversationId || raw.sessionId;
-  const sessionId = raw.sessionId || raw.conversationId;
-  if (!conversationId || !sessionId)
-    return;
-  const normalized = {
-    provider: "claudeCode",
-    conversationId,
-    sessionId,
-    cwd: raw.cwd,
-    lastSeenAt: raw.lastSeenAt
-  };
-  return normalized;
-}
-function normalizeOptionalString(raw) {
-  return typeof raw === "string" && raw.trim() ? raw.trim() : undefined;
-}
-function normalizeWorktreeMeta(meta) {
-  const conversation = normalizeConversationMeta(meta.conversation);
-  const normalizedLabel = normalizeOptionalString(meta.label);
-  if (conversation === meta.conversation && normalizedLabel === meta.label) {
-    return meta;
-  }
-  const rest = { ...meta };
-  delete rest.label;
-  delete rest.conversation;
-  return {
-    ...rest,
-    ...normalizedLabel ? { label: normalizedLabel } : {},
-    ...conversation !== undefined ? { conversation } : {}
-  };
-}
-function isPrComment(raw) {
-  if (!isRecord4(raw))
-    return false;
-  return (raw.type === "comment" || raw.type === "inline") && typeof raw.author === "string" && typeof raw.body === "string" && typeof raw.createdAt === "string" && (raw.path === undefined || typeof raw.path === "string") && (raw.line === undefined || raw.line === null || typeof raw.line === "number") && (raw.diffHunk === undefined || typeof raw.diffHunk === "string") && (raw.isReply === undefined || typeof raw.isReply === "boolean");
-}
-function isCiCheck(raw) {
-  if (!isRecord4(raw))
-    return false;
-  return typeof raw.name === "string" && (raw.status === "pending" || raw.status === "success" || raw.status === "failed" || raw.status === "skipped") && (raw.url === null || typeof raw.url === "string") && (raw.runId === null || typeof raw.runId === "number");
-}
-function isPrEntry(raw) {
-  if (!isRecord4(raw))
-    return false;
-  return typeof raw.repo === "string" && typeof raw.number === "number" && (raw.state === "open" || raw.state === "closed" || raw.state === "merged") && typeof raw.url === "string" && typeof raw.updatedAt === "string" && (raw.ciStatus === "none" || raw.ciStatus === "pending" || raw.ciStatus === "success" || raw.ciStatus === "failed") && Array.isArray(raw.ciChecks) && raw.ciChecks.every((check) => isCiCheck(check)) && Array.isArray(raw.comments) && raw.comments.every((comment) => isPrComment(comment));
-}
-async function readWorktreePrs(gitDir) {
-  const { prsPath } = getWorktreeStoragePaths(gitDir);
-  try {
-    const raw = await Bun.file(prsPath).json();
-    return Array.isArray(raw) && raw.every((entry) => isPrEntry(entry)) ? raw : [];
-  } catch {
-    return [];
-  }
-}
-async function writeWorktreePrs(gitDir, prs) {
-  const { prsPath } = await ensureWorktreeStorageDirs(gitDir);
-  await Bun.write(prsPath, JSON.stringify(prs, null, 2) + `
-`);
-}
-
-// backend/src/adapters/agent-runtime.ts
-var GENERATED_CODEX_HOOKS_EXCLUDE = ".codex/hooks.json";
-function shellQuote(value) {
-  return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function isRecord5(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function buildAgentCtlScript() {
   return `#!/usr/bin/env python3
@@ -15472,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, "");
 }
@@ -15561,7 +15761,8 @@ function buildBuiltInAgentInvocation(input) {
     const hooksFlag = " --enable hooks";
     const yoloFlag2 = input.yolo ? " --yolo" : "";
     if (input.launchMode === "resume") {
-      return `codex${hooksFlag}${yoloFlag2} resume --last${promptSuffix}`;
+      const resumeTarget = input.resumeConversationId ? ` ${quoteShell(input.resumeConversationId)}` : " --last";
+      return `codex${hooksFlag}${yoloFlag2} resume${resumeTarget}${promptSuffix}`;
     }
     if (input.systemPrompt) {
       return `codex${hooksFlag}${yoloFlag2} -c ${quoteShell(`developer_instructions=${input.systemPrompt}`)}${promptSuffix}`;
@@ -15604,7 +15805,8 @@ function buildAgentInvocation(input) {
       yolo: input.yolo,
       systemPrompt: input.systemPrompt,
       prompt: input.prompt,
-      launchMode: input.launchMode
+      launchMode: input.launchMode,
+      resumeConversationId: input.resumeConversationId
     });
   }
   return buildCustomAgentInvocation({
@@ -16248,6 +16450,17 @@ function buildRuntimeControlBaseUrl(controlBaseUrl, runtime) {
     return trimmed;
   }
 }
+function resolveCodexResumeConversationId(meta, agent, launchMode) {
+  if (launchMode !== "resume")
+    return;
+  if (meta.agentTerminalStale !== true)
+    return;
+  if (agent.kind !== "builtin" || agent.implementation.agent !== "codex")
+    return;
+  if (meta.conversation?.provider !== "codexAppServer")
+    return;
+  return meta.conversation.threadId;
+}
 function prefixAgentBranch(agent, branch) {
   return `${agent}-${branch}`;
 }
@@ -16329,6 +16542,7 @@ class LifecycleService {
       const { profileName, profile } = this.resolveProfile(initialized.meta.profile);
       const agent = this.resolveAgentDefinition(initialized.meta.agent);
       const launchMode = resolved.meta && agent.capabilities.resume ? "resume" : "fresh";
+      const resumeConversationId = resolveCodexResumeConversationId(initialized.meta, agent, launchMode);
       await ensureAgentRuntimeArtifacts({
         gitDir: initialized.paths.gitDir,
         worktreePath: resolved.entry.path
@@ -16341,7 +16555,57 @@ class LifecycleService {
         initialized,
         worktreePath: resolved.entry.path,
         launchMode,
-        followUpPrompt: options.prompt
+        followUpPrompt: options.prompt,
+        resumeConversationId
+      });
+      if (initialized.meta.agentTerminalStale === true) {
+        await writeWorktreeMeta(resolved.gitDir, {
+          ...initialized.meta,
+          agentTerminalStale: false
+        });
+      }
+      await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
+      return {
+        branch,
+        worktreeId: initialized.meta.worktreeId
+      };
+    } catch (error) {
+      throw this.wrapOperationError(error);
+    }
+  }
+  async refreshAgentTerminal(branch) {
+    try {
+      const resolved = await this.resolveExistingWorktree(branch);
+      if (!resolved.meta) {
+        throw new LifecycleError(`Worktree ${branch} has no managed metadata to refresh`, 409);
+      }
+      const initialized = await this.refreshManagedArtifacts(resolved);
+      const { profileName, profile } = this.resolveProfile(initialized.meta.profile);
+      const agent = this.resolveAgentDefinition(initialized.meta.agent);
+      if (agent.kind !== "builtin" || agent.implementation.agent !== "codex") {
+        throw new LifecycleError("Refreshing the agent terminal is only available for Codex worktrees", 409);
+      }
+      const conversation = initialized.meta.conversation;
+      if (conversation?.provider !== "codexAppServer") {
+        throw new LifecycleError("No Codex conversation is available to refresh", 409);
+      }
+      await ensureAgentRuntimeArtifacts({
+        gitDir: initialized.paths.gitDir,
+        worktreePath: resolved.entry.path
+      });
+      await this.materializeRuntimeSession({
+        branch,
+        profileName,
+        profile,
+        agent,
+        initialized,
+        worktreePath: resolved.entry.path,
+        launchMode: "resume",
+        resumeConversationId: conversation.threadId
+      });
+      await writeWorktreeMeta(resolved.gitDir, {
+        ...initialized.meta,
+        agentTerminalStale: false
       });
       await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
       return {
@@ -16656,6 +16920,7 @@ class LifecycleService {
         followUpPrompt: input.followUpPrompt,
         launchMode: input.launchMode,
         source: input.source,
+        resumeConversationId: input.resumeConversationId,
         containerName
       }));
       return;
@@ -16670,7 +16935,8 @@ class LifecycleService {
       creationPrompt: input.creationPrompt,
       followUpPrompt: input.followUpPrompt,
       launchMode: input.launchMode,
-      source: input.source
+      source: input.source,
+      resumeConversationId: input.resumeConversationId
     }));
   }
   buildSessionLayout(input) {
@@ -16695,7 +16961,8 @@ ${oneshotPrompt}` : oneshotPrompt ?? baseSystemPrompt;
           yolo: input.profile.yolo === true,
           systemPrompt,
           prompt,
-          launchMode: input.launchMode
+          launchMode: input.launchMode,
+          resumeConversationId: input.resumeConversationId
         }),
         shell: buildDockerShellCommand(containerName, input.worktreePath, input.initialized.paths.runtimeEnvPath)
       } : {
@@ -16709,7 +16976,8 @@ ${oneshotPrompt}` : oneshotPrompt ?? baseSystemPrompt;
           yolo: input.profile.yolo === true,
           systemPrompt,
           prompt,
-          launchMode: input.launchMode
+          launchMode: input.launchMode,
+          resumeConversationId: input.resumeConversationId
         }),
         shell: buildManagedShellCommand(input.initialized.paths.runtimeEnvPath)
       }
@@ -17445,9 +17713,10 @@ async function runLinearAutoCreateOnce(deps) {
     for (const issue of oneshotIssues) {
       try {
         log.info(`[linear-auto-create] launching oneshot for ${issue.identifier}: ${issue.title}`);
-        await deps.runOneshotForIssue(issue.identifier);
+        const { branch } = await deps.runOneshotForIssue(issue.identifier);
         processedIssueIds.add(issue.id);
-        log.info(`[linear-auto-create] launched oneshot for ${issue.identifier}`);
+        log.info(`[linear-auto-create] launched oneshot for ${issue.identifier} on ${branch}`);
+        await notifyOneshotPickup(deps, issue, branch);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         log.error(`[linear-auto-create] failed to launch oneshot for ${issue.identifier}: ${msg}`);
@@ -17477,6 +17746,16 @@ ${issue.description ?? ""}`.trim()
     }
   }
 }
+async function notifyOneshotPickup(deps, issue, branch) {
+  if (!deps.onOneshotPickedUp)
+    return;
+  try {
+    await deps.onOneshotPickedUp({ issue, branch });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.warn(`[linear-auto-create] pickup notification failed for ${issue.identifier}: ${msg}`);
+  }
+}
 function startLinearAutoCreateMonitor(deps, options = {}) {
   log.info(`[linear-auto-create] monitor started (interval: ${LINEAR_AUTO_CREATE_POLL_INTERVAL_MS}ms)`);
   return startSerializedInterval(() => runLinearAutoCreateOnce(deps), LINEAR_AUTO_CREATE_POLL_INTERVAL_MS, options.intervalDeps);
@@ -17662,182 +17941,6 @@ function startAutoPullMonitor(deps, intervalMs) {
   return startSerializedInterval(run, intervalMs);
 }
 
-// backend/src/services/agents-ui-stream-service.ts
-function readNotificationParams(raw) {
-  return isRecord2(raw) ? raw : null;
-}
-function readThreadId(raw) {
-  return typeof raw === "string" && raw.length > 0 ? raw : null;
-}
-function readNotificationItemType(raw) {
-  if (!isRecord2(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,
-    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,
-    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;
@@ -17851,6 +17954,7 @@ function buildAgentsUiWorktreeSummary(worktree, conversation) {
     profile: worktree.profile,
     agentName: worktree.agentName,
     agentLabel: worktree.agentLabel,
+    agentTerminalStale: worktree.agentTerminalStale,
     mux: worktree.mux,
     status: worktree.status,
     dirty: worktree.dirty,
@@ -17867,134 +17971,309 @@ 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";
+// 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 isClaudeConversationMeta(meta) {
-  return meta?.provider === "claudeCode";
-}
-function buildPendingConversationId(worktree) {
-  return `claude-pending:${worktree.path}`;
-}
-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 normalizeSessionMessages(messages) {
-  return messages.map((message) => ({
-    ...message,
-    status: "completed"
-  }));
+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 buildConversationState(worktree, session) {
-  return {
-    provider: "claudeCode",
-    conversationId: session?.sessionId ?? buildPendingConversationId(worktree),
-    cwd: worktree.path,
-    running: false,
-    activeTurnId: null,
-    messages: normalizeSessionMessages(session?.messages ?? [])
-  };
+function compactJson2(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
 }
-function toWorktreeConversationResponse(worktree, conversationMeta, session) {
-  return {
-    worktree: buildAgentsUiWorktreeSummary(worktree, conversationMeta),
-    conversation: buildConversationState(worktree, session)
-  };
+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();
 }
-
-class ClaudeConversationService {
-  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, async (resolved) => ok(toWorktreeConversationResponse(worktree, resolved.conversationMeta, resolved.session)));
-  }
-  async readWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, async (resolved) => ok(toWorktreeConversationResponse(worktree, resolved.conversationMeta, resolved.session)));
+function parseArgumentsRecord(raw) {
+  if (!raw)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
   }
-  async withResolvedConversation(worktree, fn) {
-    if (!isClaudeWorktree(worktree)) {
-      return err(409, "Worktree chat is only available for Claude worktrees");
-    }
-    try {
-      const resolved = await this.resolveConversation(worktree);
-      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);
+  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);
     }
   }
-  async resolveConversation(worktree) {
-    const gitDir = this.deps.git.resolveWorktreeGitDir(worktree.path);
-    const meta = await this.readMeta(gitDir);
-    if (!meta) {
-      return err(409, "Worktree metadata is missing");
+  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;
     }
-    const session = await this.resolveSession(meta, worktree.path);
-    const conversationMeta = session ? await this.persistConversationMeta(gitDir, meta, worktree.path, session.sessionId) : null;
-    return ok({
-      conversationMeta,
-      session
-    });
-  }
-  async resolveSession(meta, cwd) {
-    const savedSessionId = isClaudeConversationMeta(meta.conversation) ? meta.conversation.sessionId : null;
-    const discovered = (await this.deps.claude.listSessions(cwd))[0] ?? null;
-    if (discovered && discovered.sessionId !== savedSessionId) {
-      const session = await this.deps.claude.readSession(discovered.sessionId, cwd);
-      if (session)
-        return session;
+    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 (savedSessionId) {
-      const savedSession = await this.deps.claude.readSession(savedSessionId, cwd);
-      if (savedSession)
-        return savedSession;
-      log.warn(`[agents] saved Claude session missing, rediscovering cwd=${cwd} sessionId=${savedSessionId}`);
+    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 (!discovered)
-      return null;
-    return await this.deps.claude.readSession(discovered.sessionId, cwd);
-  }
-  async persistConversationMeta(gitDir, meta, cwd, sessionId) {
-    const nextConversation = buildClaudeConversationMeta(sessionId, cwd, this.now());
-    if (!sameConversationMeta(meta.conversation, nextConversation)) {
-      await this.writeMeta(gitDir, {
-        ...meta,
-        conversation: nextConversation
+    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 nextConversation;
   }
+  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";
 }
@@ -18012,9 +18291,126 @@ function isUserMessageItem(item) {
 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";
 }
@@ -18026,76 +18422,823 @@ function findActiveTurn(thread) {
   }
   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) {
-      if (isUserMessageItem(item)) {
-        const text = extractUserText(item);
-        if (text.length === 0)
-          continue;
-        messages.push({
-          id: item.id,
-          turnId: turn.id,
-          role: "user",
-          text,
-          status: "completed",
-          createdAt: toIsoTimestamp(turn.startedAt)
-        });
-        continue;
-      }
-      if (!isAgentMessageItem(item))
-        continue;
-      if (item.text.length === 0)
-        continue;
-      messages.push({
-        id: item.id,
+      const itemMessages = buildCodexItemConversationMessages({
+        item,
         turnId: turn.id,
-        role: "assistant",
-        text: item.text,
-        status: isActiveTurnStatus(turn.status) ? "inProgress" : "completed",
-        createdAt: toIsoTimestamp(turn.completedAt ?? turn.startedAt)
+        turnStatus: turn.status,
+        createdAt: toIsoTimestamp(isUserMessageItem(item) ? turn.startedAt : turn.completedAt ?? turn.startedAt),
+        order
       });
+      messages.push(...itemMessages);
+      order += itemMessages.length;
     }
   }
   return messages;
 }
-function buildConversationState2(thread) {
+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: buildConversationMessages(thread)
+    messages
   };
 }
-function selectDiscoveredThread(threads) {
-  if (threads.length === 0)
-    return null;
-  return [...threads].sort((left, right) => right.updatedAt - left.updatedAt)[0] ?? null;
+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 buildConversationMeta(thread, now) {
+function buildPendingConversationId(worktree) {
+  return `claude-pending:${worktree.path}`;
+}
+function buildClaudeConversationMeta(sessionId, cwd, now) {
   return {
-    provider: "codexAppServer",
-    conversationId: thread.id,
-    threadId: thread.id,
-    cwd: thread.cwd,
+    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 toWorktreeConversationResponse2(worktree, conversationMeta, thread) {
+function normalizeSessionMessages(messages) {
+  return messages.map((message, order) => ({
+    ...message,
+    order,
+    kind: message.kind ?? "text",
+    status: "completed"
+  }));
+}
+function buildConversationState2(worktree, session) {
+  return {
+    provider: "claudeCode",
+    conversationId: session?.sessionId ?? buildPendingConversationId(worktree),
+    cwd: worktree.path,
+    running: false,
+    activeTurnId: null,
+    messages: normalizeSessionMessages(session?.messages ?? [])
+  };
+}
+function toWorktreeConversationResponse2(worktree, conversationMeta, session) {
   return {
     worktree: buildAgentsUiWorktreeSummary(worktree, conversationMeta),
-    conversation: buildConversationState2(thread)
+    conversation: buildConversationState2(worktree, session)
   };
 }
 
-class WorktreeConversationService {
+class ClaudeConversationService {
   deps;
   now;
   readMeta;
@@ -18107,17 +19250,17 @@ class WorktreeConversationService {
     this.writeMeta = deps.writeMeta ?? writeWorktreeMeta;
   }
   async attachWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, true, async ({ conversationMeta, thread }) => ok(toWorktreeConversationResponse2(worktree, conversationMeta, thread)));
+    return await this.withResolvedConversation(worktree, async (resolved) => ok(toWorktreeConversationResponse2(worktree, resolved.conversationMeta, resolved.session)));
   }
   async readWorktreeConversation(worktree) {
-    return await this.withResolvedConversation(worktree, false, async ({ conversationMeta, thread }) => ok(toWorktreeConversationResponse2(worktree, conversationMeta, thread)));
+    return await this.withResolvedConversation(worktree, async (resolved) => ok(toWorktreeConversationResponse2(worktree, resolved.conversationMeta, resolved.session)));
   }
-  async withResolvedConversation(worktree, allowCreate, fn) {
-    if (!isCodexWorktree(worktree)) {
-      return err(409, "Worktree chat is only available for Codex worktrees");
+  async withResolvedConversation(worktree, fn) {
+    if (!isClaudeWorktree(worktree)) {
+      return err(409, "Worktree chat is only available for Claude worktrees");
     }
     try {
-      const resolved = await this.resolveConversation(worktree, allowCreate);
+      const resolved = await this.resolveConversation(worktree);
       if (!resolved.ok)
         return resolved;
       return await fn(resolved.data);
@@ -18126,73 +19269,46 @@ class WorktreeConversationService {
       return err(502, message);
     }
   }
-  async resolveConversation(worktree, allowCreate) {
+  async resolveConversation(worktree) {
     const gitDir = this.deps.git.resolveWorktreeGitDir(worktree.path);
     const meta = await this.readMeta(gitDir);
     if (!meta) {
       return err(409, "Worktree metadata is missing");
     }
-    const now = this.now();
-    const thread = await this.resolveThread(meta, worktree.path, allowCreate);
-    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);
-    }
+    const session = await this.resolveSession(meta, worktree.path);
+    const conversationMeta = session ? await this.persistConversationMeta(gitDir, meta, worktree.path, session.sessionId) : null;
     return ok({
-      gitDir,
-      meta: nextMeta,
-      thread,
-      conversationMeta: nextMeta.conversation ?? conversationMeta
+      conversationMeta,
+      session
     });
   }
-  async resolveThread(meta, cwd, allowCreate) {
-    const discoveredThread = selectDiscoveredThread((await this.deps.appServer.threadList({
-      cwd,
-      limit: 20,
-      sortKey: "updated_at"
-    })).data);
-    if (discoveredThread) {
-      return await this.ensureThreadLoaded(discoveredThread.id, cwd);
+  async resolveSession(meta, cwd) {
+    const savedSessionId = isClaudeConversationMeta(meta.conversation) ? meta.conversation.sessionId : null;
+    const discovered = (await this.deps.claude.listSessions(cwd))[0] ?? null;
+    if (discovered && discovered.sessionId !== savedSessionId) {
+      const session = await this.deps.claude.readSession(discovered.sessionId, cwd);
+      if (session)
+        return session;
     }
-    const savedThreadId = isCodexConversationMeta(meta.conversation) ? meta.conversation.threadId : null;
-    if (savedThreadId) {
-      const savedThread = await this.tryLoadThread(savedThreadId, cwd);
-      if (savedThread)
-        return savedThread;
-      log.warn(`[agents] saved codex thread missing, rediscovering cwd=${cwd} threadId=${savedThreadId}`);
+    if (savedSessionId) {
+      const savedSession = await this.deps.claude.readSession(savedSessionId, cwd);
+      if (savedSession)
+        return savedSession;
+      log.warn(`[agents] saved Claude session missing, rediscovering cwd=${cwd} sessionId=${savedSessionId}`);
     }
-    if (!allowCreate)
-      return null;
-    const started = await this.deps.appServer.threadStart({
-      cwd,
-      approvalPolicy: "never",
-      personality: "pragmatic",
-      sandbox: "danger-full-access"
-    });
-    return started.thread;
-  }
-  async tryLoadThread(threadId, cwd) {
-    try {
-      return await this.ensureThreadLoaded(threadId, cwd);
-    } catch {
+    if (!discovered)
       return null;
-    }
+    return await this.deps.claude.readSession(discovered.sessionId, cwd);
   }
-  async ensureThreadLoaded(threadId, cwd) {
-    const initial = await this.deps.appServer.threadRead(threadId, false);
-    if (initial.thread.status.type === "notLoaded") {
-      await this.deps.appServer.threadResume({
-        threadId,
-        cwd,
-        approvalPolicy: "never",
-        personality: "pragmatic"
+  async persistConversationMeta(gitDir, meta, cwd, sessionId) {
+    const nextConversation = buildClaudeConversationMeta(sessionId, cwd, this.now());
+    if (!sameConversationMeta2(meta.conversation, nextConversation)) {
+      await this.writeMeta(gitDir, {
+        ...meta,
+        conversation: nextConversation
       });
     }
-    return (await this.deps.appServer.threadRead(threadId, true)).thread;
+    return nextConversation;
   }
 }
 
@@ -18605,49 +19721,15 @@ class BunPortProbe {
   }
 }
 
-// backend/src/services/auto-name-service.ts
-var MAX_BRANCH_LENGTH = 40;
-var DEFAULT_AUTO_NAME_MODEL = "claude-haiku-4-5-20251001";
-var AUTO_NAME_TIMEOUT_MS = 15000;
-var DEFAULT_SYSTEM_PROMPT = [
-  "Generate a concise git branch name from the task description.",
-  "Return only the branch name.",
-  "Use lowercase kebab-case.",
-  `Maximum ${MAX_BRANCH_LENGTH} characters.`,
-  "Do not include quotes, code fences, or prefixes like feature/ or fix/."
-].join(" ");
-function normalizeGeneratedBranchName(raw) {
-  let branch = raw.trim();
-  branch = branch.replace(/^```[\w-]*\s*/, "").replace(/\s*```$/, "");
-  branch = branch.split(/\r?\n/)[0]?.trim() ?? "";
-  branch = branch.replace(/^branch(?:\s+name)?\s*:\s*/i, "");
-  branch = branch.replace(/^["'`]+|["'`]+$/g, "");
-  branch = branch.toLowerCase();
-  branch = branch.replace(/[^a-z0-9._/-]+/g, "-");
-  branch = branch.replace(/[/.]+/g, "-");
-  branch = branch.replace(/-+/g, "-");
-  branch = branch.replace(/^-+|-+$/g, "");
-  branch = branch.slice(0, MAX_BRANCH_LENGTH).replace(/-+$/, "");
-  if (!branch) {
-    throw new Error("Auto-name model returned an empty branch name");
-  }
-  if (!isValidBranchName(branch)) {
-    throw new Error(`Auto-name model returned an invalid branch name: ${branch}`);
-  }
-  return branch;
-}
-function getSystemPrompt(config) {
-  return config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
-}
-
-class AutoNameTimeoutError extends Error {
+// backend/src/services/llm-spawn.ts
+class LlmSpawnTimeoutError extends Error {
   timeoutMs;
   constructor(timeoutMs) {
-    super(`Auto-name timed out after ${timeoutMs}ms`);
+    super(`LLM spawn timed out after ${timeoutMs}ms`);
     this.timeoutMs = timeoutMs;
   }
 }
-async function defaultSpawn(args, options = {}) {
+async function defaultLlmSpawn(args, options = {}) {
   const proc = Bun.spawn(args, {
     stdout: "pipe",
     stderr: "pipe"
@@ -18657,7 +19739,8 @@ async function defaultSpawn(args, options = {}) {
     new Response(proc.stderr).text(),
     proc.exited
   ]).then(([stdout, stderr, exitCode]) => ({ exitCode, stdout, stderr }));
-  if (options.timeoutMs === undefined) {
+  const timeoutMs = options.timeoutMs;
+  if (timeoutMs === undefined) {
     return await resultPromise;
   }
   return await new Promise((resolve8, reject) => {
@@ -18669,8 +19752,8 @@ async function defaultSpawn(args, options = {}) {
       try {
         proc.kill("SIGKILL");
       } catch {}
-      reject(new AutoNameTimeoutError(options.timeoutMs));
-    }, options.timeoutMs);
+      reject(new LlmSpawnTimeoutError(timeoutMs));
+    }, timeoutMs);
     resultPromise.then((result) => {
       if (settled)
         return;
@@ -18686,30 +19769,27 @@ async function defaultSpawn(args, options = {}) {
     });
   });
 }
-function buildClaudeArgs(model, systemPrompt, prompt) {
-  const args = [
-    "claude",
-    "-p",
-    "--system-prompt",
-    systemPrompt,
-    "--output-format",
-    "text",
-    "--no-session-persistence",
-    "--model",
-    model || DEFAULT_AUTO_NAME_MODEL,
-    "--effort",
-    "low"
-  ];
-  args.push(prompt);
-  return args;
-}
 function escapeTomlString(s) {
   return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
 }
-function buildPrompt(prompt) {
-  return `Here is the task description: ${prompt}. You MUST return the branch name only, no other text or comments. Be fast, make it simple, and concise.`;
-}
-function buildCodexArgs(model, systemPrompt, prompt) {
+var DEFAULT_CLAUDE_MODEL = "claude-haiku-4-5-20251001";
+function buildLlmArgs(config, systemPrompt, userPrompt) {
+  if (config.provider === "claude") {
+    return [
+      "claude",
+      "-p",
+      "--system-prompt",
+      systemPrompt,
+      "--output-format",
+      "text",
+      "--no-session-persistence",
+      "--model",
+      config.model || DEFAULT_CLAUDE_MODEL,
+      "--effort",
+      "low",
+      userPrompt
+    ];
+  }
   const args = [
     "codex",
     "-c",
@@ -18717,18 +19797,82 @@ function buildCodexArgs(model, systemPrompt, prompt) {
     "exec",
     "--ephemeral"
   ];
-  if (model) {
-    args.push("-m", model);
+  if (config.model) {
+    args.push("-m", config.model);
   }
-  args.push(prompt);
+  args.push(userPrompt);
   return args;
 }
+async function runShortLlmTask(config, systemPrompt, userPrompt, options = {}) {
+  const args = buildLlmArgs(config, systemPrompt, userPrompt);
+  const spawnImpl = options.spawnImpl ?? defaultLlmSpawn;
+  let result;
+  try {
+    result = await spawnImpl(args, { timeoutMs: options.timeoutMs });
+  } catch (error) {
+    if (error instanceof LlmSpawnTimeoutError) {
+      return { ok: false, kind: "timeout", timeoutMs: error.timeoutMs, args };
+    }
+    return { ok: false, kind: "spawn_error", error, args };
+  }
+  if (result.exitCode !== 0) {
+    return {
+      ok: false,
+      kind: "exit_nonzero",
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      args
+    };
+  }
+  return { ok: true, stdout: result.stdout, stderr: result.stderr, args };
+}
+function llmProviderLabel(config) {
+  return config.provider === "claude" ? "claude" : "codex";
+}
+
+// backend/src/services/auto-name-service.ts
+var MAX_BRANCH_LENGTH = 40;
+var AUTO_NAME_TIMEOUT_MS = 15000;
+var DEFAULT_SYSTEM_PROMPT = [
+  "Generate a concise git branch name from the task description.",
+  "Return only the branch name.",
+  "Use lowercase kebab-case.",
+  `Maximum ${MAX_BRANCH_LENGTH} characters.`,
+  "Do not include quotes, code fences, or prefixes like feature/ or fix/."
+].join(" ");
+function normalizeGeneratedBranchName(raw) {
+  let branch = raw.trim();
+  branch = branch.replace(/^```[\w-]*\s*/, "").replace(/\s*```$/, "");
+  branch = branch.split(/\r?\n/)[0]?.trim() ?? "";
+  branch = branch.replace(/^branch(?:\s+name)?\s*:\s*/i, "");
+  branch = branch.replace(/^["'`]+|["'`]+$/g, "");
+  branch = branch.toLowerCase();
+  branch = branch.replace(/[^a-z0-9._/-]+/g, "-");
+  branch = branch.replace(/[/.]+/g, "-");
+  branch = branch.replace(/-+/g, "-");
+  branch = branch.replace(/^-+|-+$/g, "");
+  branch = branch.slice(0, MAX_BRANCH_LENGTH).replace(/-+$/, "");
+  if (!branch) {
+    throw new Error("Auto-name model returned an empty branch name");
+  }
+  if (!isValidBranchName(branch)) {
+    throw new Error(`Auto-name model returned an invalid branch name: ${branch}`);
+  }
+  return branch;
+}
+function getSystemPrompt(config) {
+  return config.systemPrompt?.trim() || DEFAULT_SYSTEM_PROMPT;
+}
+function buildPrompt(prompt) {
+  return `Here is the task description: ${prompt}. You MUST return the branch name only, no other text or comments. Be fast, make it simple, and concise.`;
+}
 
 class AutoNameService {
   spawnImpl;
   timeoutMs;
   constructor(deps = {}) {
-    this.spawnImpl = deps.spawnImpl ?? defaultSpawn;
+    this.spawnImpl = deps.spawnImpl;
     this.timeoutMs = deps.timeoutMs ?? AUTO_NAME_TIMEOUT_MS;
   }
   async generateBranchName(config, task) {
@@ -18738,24 +19882,24 @@ class AutoNameService {
     }
     const systemPrompt = getSystemPrompt(config);
     const userPrompt = buildPrompt(prompt);
-    const args = config.provider === "claude" ? buildClaudeArgs(config.model, systemPrompt, userPrompt) : buildCodexArgs(config.model, systemPrompt, userPrompt);
-    const cli = config.provider === "claude" ? "claude" : "codex";
-    let result;
-    try {
-      result = await this.spawnImpl(args, { timeoutMs: this.timeoutMs });
-    } catch (error) {
-      if (error instanceof AutoNameTimeoutError) {
+    const cli = llmProviderLabel(config);
+    const runOptions = { timeoutMs: this.timeoutMs };
+    if (this.spawnImpl)
+      runOptions.spawnImpl = this.spawnImpl;
+    const result = await runShortLlmTask(config, systemPrompt, userPrompt, runOptions);
+    if (!result.ok) {
+      if (result.kind === "timeout") {
         const fallback = generateFallbackBranchName();
         log.warn(`[auto-name] ${cli} timed out after ${this.timeoutMs}ms; using fallback branch ${fallback}`);
         return fallback;
       }
-      throw new Error(`'${cli}' CLI not found. Install it or check your PATH.`);
-    }
-    if (result.exitCode !== 0) {
+      if (result.kind === "spawn_error") {
+        throw new Error(`'${cli}' CLI not found. Install it or check your PATH.`);
+      }
       const stderr = result.stderr.trim();
       const stdout = result.stdout.trim();
       const output2 = stderr || stdout || `exit ${result.exitCode}`;
-      const command = args.join(" ");
+      const command = result.args.join(" ");
       throw new Error(`${cli} failed (command: ${command}): ${output2}`);
     }
     const output = result.stdout.trim();
@@ -18938,6 +20082,7 @@ function makeDefaultState(input) {
     agentName: input.agentName ?? null,
     source: input.source ?? "ui",
     oneshot: input.oneshot ?? null,
+    agentTerminalStale: input.agentTerminalStale === true,
     git: {
       exists: true,
       branch: input.branch,
@@ -18985,6 +20130,8 @@ class ProjectRuntime {
         existing.baseBranch = input.baseBranch;
       existing.profile = input.profile ?? existing.profile;
       existing.agentName = input.agentName ?? existing.agentName;
+      if (input.agentTerminalStale !== undefined)
+        existing.agentTerminalStale = input.agentTerminalStale;
       if (input.runtime)
         existing.agent.runtime = input.runtime;
       if (input.source !== undefined)
@@ -19046,6 +20193,11 @@ class ProjectRuntime {
     state.prs = prs.map((pr) => clonePrEntry2(pr));
     return state;
   }
+  setAgentTerminalStale(worktreeId, stale) {
+    const state = this.requireWorktree(worktreeId);
+    state.agentTerminalStale = stale;
+    return state;
+  }
   applyEvent(event, now) {
     const state = this.requireWorktree(event.worktreeId);
     if (event.branch !== state.branch) {
@@ -19198,6 +20350,7 @@ class ReconciliationService {
         path: entry.path,
         profile: meta?.profile ?? null,
         agentName: meta?.agent ?? null,
+        agentTerminalStale: meta?.agentTerminalStale === true,
         runtime: meta?.runtime ?? "host",
         source: meta?.source ?? "ui",
         oneshot: meta?.oneshot ?? null,
@@ -19233,6 +20386,7 @@ class ReconciliationService {
         path: state.path,
         profile: state.profile,
         agentName: state.agentName,
+        agentTerminalStale: state.agentTerminalStale,
         runtime: state.runtime,
         source: state.source,
         oneshot: state.oneshot
@@ -19489,7 +20643,12 @@ var codexAppServerClient = new CodexAppServerClient({
 var claudeCliClient = new ClaudeCliClient;
 var worktreeConversationService = new WorktreeConversationService({
   appServer: codexAppServerClient,
-  git
+  git,
+  resolveLaunchContext: ({ worktree, meta }) => resolveCodexAppServerLaunchContext({
+    worktree,
+    meta,
+    profile: config.profiles[meta.profile]
+  })
 });
 var claudeConversationService = new ClaudeConversationService({
   claude: claudeCliClient,
@@ -19521,6 +20680,7 @@ async function runOneshotForIssue(issueId) {
       postToLinearOnDone: { kind: "issue", issueId }
     }
   });
+  return { branch };
 }
 function startLinearAutoCreate() {
   if (stopLinearAutoCreate)
@@ -19531,9 +20691,22 @@ function startLinearAutoCreate() {
     git,
     projectRoot: PROJECT_DIR,
     runOneshotForIssue,
+    onOneshotPickedUp: postLinearOneshotPickupComment,
     ...watchTeamKeys && watchTeamKeys.length > 0 ? { watchTeamKeys } : {}
   });
 }
+async function postLinearOneshotPickupComment(input) {
+  const body = buildLinearPickupMarkdown({
+    branch: input.branch,
+    pickedUpAt: new Date
+  });
+  const result = await createIssueComment({ issueId: input.issue.id, body });
+  if (!result.ok) {
+    log.warn(`[linear-auto-create] failed to post pickup comment for ${input.issue.identifier}: ${result.error}`);
+    return;
+  }
+  log.info(`[linear-auto-create] posted pickup comment for ${input.issue.identifier}: ${result.data.url}`);
+}
 function normalizeOneshotConfig(input) {
   if (!input)
     return;
@@ -19607,7 +20780,7 @@ function parseWsMessage(raw) {
   try {
     const str = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
     const msg = JSON.parse(str);
-    if (!isRecord2(msg))
+    if (!isRecord3(msg))
       return null;
     const m = msg;
     switch (m.type) {
@@ -19839,6 +21012,19 @@ function resolveWorktreeTerminalSubmitDelayMs(agentName) {
     agent: agentName ? getAgentDefinition(config, agentName) : null
   });
 }
+async function setAgentTerminalStale(worktree, stale) {
+  const gitDir = git.resolveWorktreeGitDir(worktree.path);
+  const meta = await readWorktreeMeta(gitDir);
+  if (!meta)
+    return;
+  await writeWorktreeMeta(gitDir, {
+    ...meta,
+    agentTerminalStale: stale
+  });
+  if (projectRuntime.getWorktree(meta.worktreeId)) {
+    projectRuntime.setAgentTerminalStale(meta.worktreeId, stale);
+  }
+}
 async function apiAttachAgentsWorktree(branch) {
   touchDashboardActivity();
   const resolved = await resolveAgentsWorktree(branch);
@@ -19879,7 +21065,15 @@ async function apiSendAgentsWorktreeMessage(branch, req) {
   if (!chatSupport.ok) {
     return errorResponse(chatSupport.error, chatSupport.status);
   }
-  const conversationResult = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  if (chatSupport.data.provider === "codex") {
+    const sendResult2 = await worktreeConversationService.sendWorktreeConversationMessage(resolved.worktree, parsed.data.text);
+    if (!sendResult2.ok) {
+      return errorResponse(sendResult2.error, sendResult2.status);
+    }
+    await setAgentTerminalStale(resolved.worktree, true);
+    return jsonResponse(sendResult2.data);
+  }
+  const conversationResult = await claudeConversationService.readWorktreeConversation(resolved.worktree);
   if (!conversationResult.ok) {
     return errorResponse(conversationResult.error, conversationResult.status);
   }
@@ -19909,7 +21103,15 @@ async function apiInterruptAgentsWorktree(branch) {
   if (!chatSupport.ok) {
     return errorResponse(chatSupport.error, chatSupport.status);
   }
-  const conversationResult = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  if (chatSupport.data.provider === "codex") {
+    const interruptResult2 = await worktreeConversationService.interruptWorktreeConversation(resolved.worktree);
+    if (!interruptResult2.ok) {
+      return errorResponse(interruptResult2.error, interruptResult2.status);
+    }
+    await setAgentTerminalStale(resolved.worktree, true);
+    return jsonResponse(interruptResult2.data);
+  }
+  const conversationResult = await claudeConversationService.readWorktreeConversation(resolved.worktree);
   if (!conversationResult.ok) {
     return errorResponse(conversationResult.error, conversationResult.status);
   }
@@ -19926,7 +21128,13 @@ async function apiInterruptAgentsWorktree(branch) {
     interrupted: true
   });
 }
-async function loadAgentsConversationSnapshot(branch) {
+async function apiRefreshWorktreeAgentTerminal(branch) {
+  touchDashboardActivity();
+  ensureBranchNotBusy(branch);
+  await lifecycleService.refreshAgentTerminal(branch);
+  return jsonResponse({ ok: true });
+}
+async function loadAgentsConversationInitialState(branch) {
   const resolved = await resolveAgentsWorktree(branch);
   if (!resolved.ok) {
     return {
@@ -19949,7 +21157,7 @@ async function readErrorMessage(response) {
   if (contentType.includes("application/json")) {
     try {
       const body = await response.json();
-      if (isRecord2(body) && typeof body.error === "string" && body.error.length > 0) {
+      if (isRecord3(body) && typeof body.error === "string" && body.error.length > 0) {
         return body.error;
       }
     } catch {}
@@ -19957,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)) {
@@ -20442,6 +21660,11 @@ async function apiGetLinearIssues() {
     return errorResponse(result.error, 502);
   return jsonResponse(result.data);
 }
+function apiGetAutoNameConfig() {
+  const apiKey = Bun.env.LINEAR_API_KEY;
+  const linearAvailability = !config.integrations.linear.enabled ? "disabled" : !apiKey?.trim() ? "missing_api_key" : "ready";
+  return jsonResponse({ autoName: config.autoName, linearAvailability });
+}
 var MAX_DIFF_BYTES = 200 * 1024;
 async function apiGetWorktreeDiff(name) {
   await reconciliationService.reconcile(PROJECT_DIR);
@@ -20696,6 +21919,15 @@ function startServer(port) {
           return catching(`POST /api/worktrees/${name}/close`, () => apiCloseWorktree(name));
         }
       },
+      [apiPaths.refreshWorktreeAgentTerminal]: {
+        POST: (req) => {
+          const parsed = parseWorktreeNameParam(req.params);
+          if (!parsed.ok)
+            return parsed.response;
+          const name = parsed.data;
+          return catching(`POST /api/worktrees/${name}/agent-terminal/refresh`, () => apiRefreshWorktreeAgentTerminal(name));
+        }
+      },
       [apiPaths.setWorktreeArchived]: {
         PUT: (req) => {
           const parsed = parseWorktreeNameParam(req.params);
@@ -20771,6 +22003,9 @@ function startServer(port) {
       [apiPaths.fetchLinearIssues]: {
         GET: () => catching("GET /api/linear/issues", () => apiGetLinearIssues())
       },
+      [apiPaths.fetchAutoNameConfig]: {
+        GET: () => catching("GET /api/project/auto-name", async () => apiGetAutoNameConfig())
+      },
       [apiPaths.setLinearAutoCreate]: {
         PUT: (req) => catching("PUT /api/linear/auto-create", () => apiSetLinearAutoCreate(req))
       },