webmux 0.33.0 → 0.35.0

package/backend/dist/server.js

@@ -1,17 +1,13 @@
 // @bun
 var __defProp = Object.defineProperty;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: __exportSetter.bind(all, name)
+      set: (newValue) => all[name] = () => newValue
     });
 };
 var __require = import.meta.require;
@@ -6965,7 +6961,7 @@ import { networkInterfaces } from "os";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.33.0",
+  version: "0.35.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -10994,7 +10990,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 +11297,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 +11327,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 +11376,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(),
@@ -11523,6 +11530,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 +11539,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 +11730,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 +11818,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 +12220,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 +12475,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 +12484,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 +12506,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 +12527,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 +12585,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 +12606,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 +12652,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 +12662,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 +12801,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 +12835,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) {
@@ -12603,16 +12857,11 @@ 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
-}));
+  text: exports_external.string().optional(),
+  message: exports_external.string().optional(),
+  phase: exports_external.string().optional(),
+  memoryCitation: UnknownValueSchema.optional()
+});
 var CodexAppServerGenericItemSchema = exports_external.object({
   type: exports_external.string(),
   id: exports_external.string()
@@ -12864,7 +13113,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 +13201,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 +13213,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 +13321,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 +13337,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 +13366,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 +13374,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 +13397,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 +13416,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 +13429,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 +13444,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 +13453,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 +13466,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 +13478,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 +13496,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 +13505,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 +13520,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 +13544,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 +13566,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 +13582,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 +13600,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 +13611,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 +13631,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 +13711,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 +13723,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 +13733,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 +13743,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 +13755,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 +13864,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 +14543,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}\`**`,
@@ -14674,229 +14925,6 @@ 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;
-  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("'", "'\\''")}'`;
@@ -15558,10 +15586,11 @@ function buildDockerRuntimeBootstrap(runtimeEnvPath) {
 function buildBuiltInAgentInvocation(input) {
   const promptSuffix = input.prompt ? ` -- ${quoteShell(input.prompt)}` : "";
   if (input.agent === "codex") {
-    const hooksFlag = " --enable codex_hooks";
+    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 +15633,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 +16278,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 +16370,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 +16383,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 +16748,7 @@ class LifecycleService {
         followUpPrompt: input.followUpPrompt,
         launchMode: input.launchMode,
         source: input.source,
+        resumeConversationId: input.resumeConversationId,
         containerName
       }));
       return;
@@ -16670,7 +16763,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 +16789,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 +16804,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 +17541,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 +17574,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);
@@ -17664,13 +17771,13 @@ function startAutoPullMonitor(deps, intervalMs) {
 
 // backend/src/services/agents-ui-stream-service.ts
 function readNotificationParams(raw) {
-  return isRecord2(raw) ? raw : null;
+  return isRecord3(raw) ? raw : null;
 }
 function readThreadId(raw) {
   return typeof raw === "string" && raw.length > 0 ? raw : null;
 }
 function readNotificationItemType(raw) {
-  if (!isRecord2(raw))
+  if (!isRecord3(raw))
     return null;
   return typeof raw.type === "string" ? raw.type : null;
 }
@@ -17772,6 +17879,7 @@ function mapWorktreeSnapshot(state, now, creating, isArchived, findLinearIssue,
     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,
@@ -17797,6 +17905,7 @@ function mapCreatingWorktreeSnapshot(creating, isArchived, findLinearIssue, find
     profile: creating.profile,
     agentName: creating.agentName,
     agentLabel: findAgentLabel ? findAgentLabel(creating.agentName) : creating.agentName,
+    agentTerminalStale: false,
     mux: false,
     dirty: false,
     unpushed: false,
@@ -17851,6 +17960,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,
@@ -17995,6 +18105,25 @@ class ClaudeConversationService {
 }
 
 // backend/src/services/worktree-conversation-service.ts
+function resolveCodexAppServerLaunchContext(input) {
+  if (input.worktree.agentName !== "codex" || input.meta.agent !== "codex") {
+    return err(409, "Codex web chat is only available for Codex worktrees");
+  }
+  if (!input.profile) {
+    return err(409, `Profile is missing for Codex web chat: ${input.meta.profile}`);
+  }
+  if (input.meta.runtime !== "host" || input.profile.runtime !== "host") {
+    return err(409, "Codex web chat is only available for host-runtime worktrees. Use the terminal for Docker worktrees.");
+  }
+  if (input.profile.yolo !== true) {
+    return err(409, "Codex web chat requires a yolo profile to preserve the Codex approval policy. Use the terminal for this worktree.");
+  }
+  return ok({
+    approvalPolicy: "never",
+    personality: "pragmatic",
+    sandbox: "danger-full-access"
+  });
+}
 function isCodexWorktree(worktree) {
   return worktree.agentName === "codex";
 }
@@ -18015,6 +18144,9 @@ function isAgentMessageItem(item) {
 function extractUserText(item) {
   return item.content.map((contentItem) => contentItem.text ?? "").join("").trim();
 }
+function extractAgentText(item) {
+  return item.text ?? item.message ?? "";
+}
 function isActiveTurnStatus(status) {
   return status === "inProgress" || status === "active" || status === "running" || status === "pending" || status === "queued";
 }
@@ -18031,14 +18163,14 @@ function buildConversationMessages(thread) {
   for (const turn of thread.turns) {
     for (const item of turn.items) {
       if (isUserMessageItem(item)) {
-        const text = extractUserText(item);
-        if (text.length === 0)
+        const text2 = extractUserText(item);
+        if (text2.length === 0)
           continue;
         messages.push({
           id: item.id,
           turnId: turn.id,
           role: "user",
-          text,
+          text: text2,
           status: "completed",
           createdAt: toIsoTimestamp(turn.startedAt)
         });
@@ -18046,13 +18178,14 @@ function buildConversationMessages(thread) {
       }
       if (!isAgentMessageItem(item))
         continue;
-      if (item.text.length === 0)
+      const text = extractAgentText(item);
+      if (text.length === 0)
         continue;
       messages.push({
         id: item.id,
         turnId: turn.id,
         role: "assistant",
-        text: item.text,
+        text,
         status: isActiveTurnStatus(turn.status) ? "inProgress" : "completed",
         createdAt: toIsoTimestamp(turn.completedAt ?? turn.startedAt)
       });
@@ -18112,6 +18245,39 @@ class WorktreeConversationService {
   async readWorktreeConversation(worktree) {
     return await this.withResolvedConversation(worktree, false, async ({ conversationMeta, thread }) => ok(toWorktreeConversationResponse2(worktree, conversationMeta, thread)));
   }
+  async sendWorktreeConversationMessage(worktree, text) {
+    return await this.withResolvedConversation(worktree, true, async ({ thread, launchContext }) => {
+      const started = await this.deps.appServer.turnStart({
+        threadId: thread.id,
+        cwd: worktree.path,
+        approvalPolicy: launchContext.approvalPolicy,
+        input: [{ type: "text", text }]
+      });
+      return ok({
+        conversationId: thread.id,
+        turnId: started.turn.id,
+        running: true
+      });
+    });
+  }
+  async interruptWorktreeConversation(worktree) {
+    return await this.withResolvedConversation(worktree, false, async ({ thread }) => {
+      const conversation = buildConversationState2(thread);
+      const turnId = conversation.activeTurnId;
+      if (!turnId) {
+        return err(409, "No active Codex turn to interrupt");
+      }
+      await this.deps.appServer.turnInterrupt({
+        threadId: thread.id,
+        turnId
+      });
+      return ok({
+        conversationId: thread.id,
+        turnId,
+        interrupted: true
+      });
+    });
+  }
   async withResolvedConversation(worktree, allowCreate, fn) {
     if (!isCodexWorktree(worktree)) {
       return err(409, "Worktree chat is only available for Codex worktrees");
@@ -18132,8 +18298,12 @@ class WorktreeConversationService {
     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);
+    const thread = await this.resolveThread(meta, worktree.path, allowCreate, launchContext);
     if (!thread) {
       return err(404, "No Codex thread could be resolved for this worktree");
     }
@@ -18146,21 +18316,22 @@ class WorktreeConversationService {
       gitDir,
       meta: nextMeta,
       thread,
-      conversationMeta: nextMeta.conversation ?? conversationMeta
+      conversationMeta: nextMeta.conversation ?? conversationMeta,
+      launchContext
     });
   }
-  async resolveThread(meta, cwd, allowCreate) {
+  async resolveThread(meta, cwd, allowCreate, launchContext) {
     const discoveredThread = selectDiscoveredThread((await this.deps.appServer.threadList({
       cwd,
       limit: 20,
       sortKey: "updated_at"
     })).data);
     if (discoveredThread) {
-      return await this.ensureThreadLoaded(discoveredThread.id, cwd);
+      return await this.ensureThreadLoaded(discoveredThread.id, cwd, launchContext);
     }
     const savedThreadId = isCodexConversationMeta(meta.conversation) ? meta.conversation.threadId : null;
     if (savedThreadId) {
-      const savedThread = await this.tryLoadThread(savedThreadId, cwd);
+      const savedThread = await this.tryLoadThread(savedThreadId, cwd, launchContext);
       if (savedThread)
         return savedThread;
       log.warn(`[agents] saved codex thread missing, rediscovering cwd=${cwd} threadId=${savedThreadId}`);
@@ -18169,27 +18340,28 @@ class WorktreeConversationService {
       return null;
     const started = await this.deps.appServer.threadStart({
       cwd,
-      approvalPolicy: "never",
-      personality: "pragmatic",
-      sandbox: "danger-full-access"
+      approvalPolicy: launchContext.approvalPolicy,
+      personality: launchContext.personality,
+      sandbox: launchContext.sandbox
     });
     return started.thread;
   }
-  async tryLoadThread(threadId, cwd) {
+  async tryLoadThread(threadId, cwd, launchContext) {
     try {
-      return await this.ensureThreadLoaded(threadId, cwd);
+      return await this.ensureThreadLoaded(threadId, cwd, launchContext);
     } catch {
       return null;
     }
   }
-  async ensureThreadLoaded(threadId, cwd) {
+  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: "never",
-        personality: "pragmatic"
+        approvalPolicy: launchContext.approvalPolicy,
+        personality: launchContext.personality,
+        sandbox: launchContext.sandbox
       });
     }
     return (await this.deps.appServer.threadRead(threadId, true)).thread;
@@ -18605,49 +18777,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 +18795,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 +18808,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 +18825,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 +18853,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 +18938,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 +19138,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 +19186,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 +19249,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 +19406,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 +19442,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 +19699,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 +19736,7 @@ async function runOneshotForIssue(issueId) {
       postToLinearOnDone: { kind: "issue", issueId }
     }
   });
+  return { branch };
 }
 function startLinearAutoCreate() {
   if (stopLinearAutoCreate)
@@ -19531,9 +19747,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 +19836,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 +20068,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 +20121,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 +20159,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,6 +20184,12 @@ async function apiInterruptAgentsWorktree(branch) {
     interrupted: true
   });
 }
+async function apiRefreshWorktreeAgentTerminal(branch) {
+  touchDashboardActivity();
+  ensureBranchNotBusy(branch);
+  await lifecycleService.refreshAgentTerminal(branch);
+  return jsonResponse({ ok: true });
+}
 async function loadAgentsConversationSnapshot(branch) {
   const resolved = await resolveAgentsWorktree(branch);
   if (!resolved.ok) {
@@ -19949,7 +20213,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 {}
@@ -20442,6 +20706,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 +20965,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 +21049,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))
       },
@@ -20949,16 +21230,36 @@ function startServer(port) {
 function actualPort(server, requested) {
   return server.port ?? requested;
 }
+var MAX_INCREMENTAL_BIND_ATTEMPTS = 100;
+var PORT_STRICT = Bun.env.WEBMUX_PORT_STRICT === "1";
 function bindServer() {
-  try {
-    return actualPort(startServer(PORT), PORT);
-  } catch (err2) {
-    const code = err2?.code;
-    if (code !== "EADDRINUSE")
+  if (PORT_STRICT) {
+    try {
+      return actualPort(startServer(PORT), PORT);
+    } catch (err2) {
+      const code = err2?.code;
+      if (code === "EADDRINUSE") {
+        log.error(`[serve] port ${PORT} is in use and was set explicitly; drop --port / PORT to let webmux pick a free port`);
+      }
       throw err2;
-    log.info(`[serve] port ${PORT} in use; binding to a free port`);
-    return actualPort(startServer(0), 0);
+    }
   }
+  let candidate = PORT;
+  for (let attempt = 0;attempt < MAX_INCREMENTAL_BIND_ATTEMPTS; attempt++) {
+    try {
+      const server = startServer(candidate);
+      if (attempt > 0)
+        log.info(`[serve] port ${PORT} in use; bound to ${actualPort(server, candidate)}`);
+      return actualPort(server, candidate);
+    } catch (err2) {
+      const code = err2?.code;
+      if (code !== "EADDRINUSE")
+        throw err2;
+      candidate += 1;
+    }
+  }
+  log.info(`[serve] ports ${PORT}..${PORT + MAX_INCREMENTAL_BIND_ATTEMPTS - 1} all in use; falling back to an OS-picked port`);
+  return actualPort(startServer(0), 0);
 }
 var BOUND_PORT = bindServer();
 var instanceRegistry = createInstanceRegistry();