codexui-android 0.1.102 → 0.1.104

package/dist-cli/index.js

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { createServer as createServer2 } from "http";
-import { chmodSync as chmodSync2, createWriteStream, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import { chmodSync as chmodSync2, createWriteStream, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
 import { readFile as readFile5, stat as stat7, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir7, networkInterfaces } from "os";
 import { isAbsolute as isAbsolute4, join as join10, resolve as resolve3 } from "path";
@@ -194,12 +194,12 @@ import express from "express";
 import { spawn as spawn4, spawnSync as spawnSync4 } from "child_process";
 import { createHash as createHash2, randomBytes } from "crypto";
 import { mkdtemp as mkdtemp3, readFile as readFile3, readdir as readdir2, rm as rm4, mkdir as mkdir4, stat as stat4, lstat as lstat2 } from "fs/promises";
-import { createReadStream, existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { createReadStream, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import { request as httpRequest2 } from "http";
 import { request as httpsRequest2 } from "https";
 import { homedir as homedir5 } from "os";
 import { tmpdir as tmpdir4 } from "os";
-import { basename as basename4, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "path";
+import { basename as basename4, dirname as dirname2, isAbsolute as isAbsolute2, join as join6, resolve as resolve2 } from "path";
 import { createInterface } from "readline";
 import { writeFile as writeFile4 } from "fs/promises";
 
@@ -212,7 +212,11 @@ import { join as join2 } from "path";
 var ACCOUNT_QUOTA_REFRESH_TTL_MS = 5 * 60 * 1e3;
 var ACCOUNT_QUOTA_LOADING_STALE_MS = 2 * 60 * 1e3;
 var ACCOUNT_INSPECTION_TIMEOUT_MS = 25 * 1e3;
+var LOGIN_URL_TIMEOUT_MS = 15 * 1e3;
+var LOGIN_CALLBACK_TIMEOUT_MS = 20 * 1e3;
+var LOGIN_AUTH_FILE_TIMEOUT_MS = 10 * 1e3;
 var backgroundRefreshPromise = null;
+var activeLogin = null;
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -233,6 +237,18 @@ function setJson(res, statusCode, payload) {
   res.setHeader("Content-Type", "application/json; charset=utf-8");
   res.end(JSON.stringify(payload));
 }
+async function readJsonBody(req) {
+  const rawBody = await new Promise((resolve4, reject) => {
+    let body = "";
+    req.setEncoding("utf8");
+    req.on("data", (chunk) => {
+      body += chunk;
+    });
+    req.on("end", () => resolve4(body));
+    req.on("error", reject);
+  });
+  return asRecord(rawBody.length > 0 ? JSON.parse(rawBody) : {});
+}
 function getErrorMessage(payload, fallback) {
   if (payload instanceof Error && payload.message.trim().length > 0) {
     return payload.message;
@@ -734,6 +750,134 @@ async function importAccountFromAuthPath(path) {
     accounts: sortAccounts(nextState.accounts, nextState.activeAccountId).map((entry) => toPublicAccountEntry(entry, nextState.activeAccountId))
   };
 }
+function extractLoginUrl(output) {
+  const match = output.match(/https:\/\/auth\.openai\.com\/oauth\/authorize\?\S+/u);
+  return match?.[0] ?? null;
+}
+function isLocalCallbackUrl(rawUrl) {
+  try {
+    const parsed = new URL(rawUrl);
+    if (parsed.protocol !== "http:") return false;
+    return parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]" || parsed.hostname === "::1";
+  } catch {
+    return false;
+  }
+}
+async function waitForLoginUrl() {
+  if (activeLogin?.loginUrl) return activeLogin.loginUrl;
+  return await new Promise((resolve4, reject) => {
+    const startedAt = Date.now();
+    const timer = setInterval(() => {
+      if (!activeLogin) {
+        clearInterval(timer);
+        reject(new Error("Login process is not running."));
+        return;
+      }
+      if (activeLogin.loginUrl) {
+        clearInterval(timer);
+        resolve4(activeLogin.loginUrl);
+        return;
+      }
+      if (activeLogin.exited) {
+        clearInterval(timer);
+        reject(new Error(activeLogin.output.trim() || "codex login exited before returning a login URL."));
+        return;
+      }
+      if (Date.now() - startedAt > LOGIN_URL_TIMEOUT_MS) {
+        clearInterval(timer);
+        reject(new Error("Timed out waiting for codex login URL."));
+      }
+    }, 100);
+  });
+}
+async function startCodexLogin() {
+  if (activeLogin && !activeLogin.exited) {
+    return await waitForLoginUrl();
+  }
+  const proc = spawn("codex", ["login"], {
+    env: process.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  proc.stdin.end();
+  activeLogin = {
+    proc,
+    loginUrl: null,
+    output: "",
+    exited: false,
+    exitCode: null,
+    exitSignal: null,
+    exitPromise: new Promise((resolve4) => {
+      proc.once("exit", (code, signal) => {
+        if (activeLogin?.proc === proc) {
+          activeLogin.exited = true;
+          activeLogin.exitCode = code;
+          activeLogin.exitSignal = signal;
+        }
+        resolve4();
+      });
+    })
+  };
+  const appendOutput = (chunk) => {
+    if (!activeLogin || activeLogin.proc !== proc) return;
+    activeLogin.output += chunk.toString();
+    activeLogin.loginUrl = activeLogin.loginUrl ?? extractLoginUrl(activeLogin.output);
+  };
+  proc.stdout.on("data", appendOutput);
+  proc.stderr.on("data", appendOutput);
+  proc.once("error", (error) => {
+    if (!activeLogin || activeLogin.proc !== proc) return;
+    activeLogin.exited = true;
+    activeLogin.output += error.message;
+  });
+  try {
+    return await waitForLoginUrl();
+  } catch (error) {
+    if (activeLogin?.proc === proc && !activeLogin.exited) {
+      proc.kill("SIGTERM");
+    }
+    activeLogin = null;
+    throw error;
+  }
+}
+async function curlLoginCallback(callbackUrl) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), LOGIN_CALLBACK_TIMEOUT_MS);
+  try {
+    const response = await fetch(callbackUrl, {
+      redirect: "manual",
+      signal: controller.signal
+    });
+    if (response.status >= 400) {
+      throw new Error(`Login callback returned HTTP ${response.status}.`);
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function getActiveAuthMtimeMs() {
+  try {
+    return (await stat(getActiveAuthPath())).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+async function waitForAuthFileUpdate(previousMtimeMs) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt <= LOGIN_AUTH_FILE_TIMEOUT_MS) {
+    const nextMtimeMs = await getActiveAuthMtimeMs();
+    if (nextMtimeMs !== null && (previousMtimeMs === null || nextMtimeMs > previousMtimeMs)) {
+      return;
+    }
+    await new Promise((resolve4) => setTimeout(resolve4, 250));
+  }
+}
+function stopActiveLogin() {
+  if (!activeLogin) return;
+  if (!activeLogin.exited) {
+    activeLogin.proc.kill("SIGTERM");
+  }
+  activeLogin = null;
+}
 async function handleAccountRoutes(req, res, url, context) {
   const { appServer } = context;
   if (req.method === "GET" && url.pathname === "/codex-api/accounts") {
@@ -813,6 +957,92 @@ async function handleAccountRoutes(req, res, url, context) {
     }
     return true;
   }
+  if (req.method === "POST" && url.pathname === "/codex-api/accounts/login/start") {
+    try {
+      const loginUrl = await startCodexLogin();
+      setJson(res, 200, {
+        ok: true,
+        data: {
+          loginUrl
+        }
+      });
+    } catch (error) {
+      setJson(res, 500, {
+        error: "account_login_start_failed",
+        message: getErrorMessage(error, "Failed to start codex login")
+      });
+    }
+    return true;
+  }
+  if (req.method === "POST" && url.pathname === "/codex-api/accounts/login/complete") {
+    try {
+      const payload = await readJsonBody(req);
+      const callbackUrl = typeof payload?.callbackUrl === "string" ? payload.callbackUrl.trim() : "";
+      if (!callbackUrl) {
+        setJson(res, 400, { error: "missing_callback_url", message: "Paste the localhost callback URL from the browser." });
+        return true;
+      }
+      if (!isLocalCallbackUrl(callbackUrl)) {
+        setJson(res, 400, { error: "invalid_callback_url", message: "The callback URL must use http://localhost or http://127.0.0.1." });
+        return true;
+      }
+      if (!activeLogin || activeLogin.exited) {
+        setJson(res, 409, { error: "login_not_running", message: "Start Codex login before submitting the callback URL." });
+        return true;
+      }
+      const previousAuthMtimeMs = await getActiveAuthMtimeMs();
+      await curlLoginCallback(callbackUrl);
+      await waitForAuthFileUpdate(previousAuthMtimeMs);
+      const imported = await importAccountFromAuthPath(getActiveAuthPath());
+      stopActiveLogin();
+      appServer.dispose();
+      const inspection = await validateSwitchedAccount(appServer);
+      const state = await readStoredAccountsState();
+      const importedAccountId = imported.importedAccountId;
+      const target = state.accounts.find((entry) => entry.accountId === importedAccountId) ?? null;
+      if (!target) {
+        throw new Error("account_not_found");
+      }
+      const nextEntry = {
+        ...target,
+        email: inspection.metadata.email ?? target.email,
+        planType: inspection.metadata.planType ?? target.planType,
+        lastActivatedAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+        quotaSnapshot: inspection.quotaSnapshot ?? target.quotaSnapshot,
+        quotaUpdatedAtIso: (/* @__PURE__ */ new Date()).toISOString(),
+        quotaStatus: "ready",
+        quotaError: null,
+        unavailableReason: null
+      };
+      const nextState = withUpsertedAccount({
+        activeAccountId: importedAccountId,
+        accounts: state.accounts
+      }, nextEntry);
+      await writeStoredAccountsState({
+        activeAccountId: importedAccountId,
+        accounts: nextState.accounts
+      });
+      const backgroundState = await scheduleAccountsBackgroundRefresh({
+        force: true,
+        prioritizeAccountId: importedAccountId,
+        accountIds: nextState.accounts.filter((entry) => entry.accountId !== importedAccountId).map((entry) => entry.accountId)
+      });
+      setJson(res, 200, {
+        ok: true,
+        data: {
+          activeAccountId: importedAccountId,
+          importedAccountId,
+          accounts: sortAccounts(backgroundState.accounts, importedAccountId).map((entry) => toPublicAccountEntry(entry, importedAccountId))
+        }
+      });
+    } catch (error) {
+      setJson(res, 500, {
+        error: "account_login_complete_failed",
+        message: getErrorMessage(error, "Failed to complete Codex login")
+      });
+    }
+    return true;
+  }
   if (req.method === "POST" && url.pathname === "/codex-api/accounts/switch") {
     try {
       if (appServer.listPendingServerRequests().length > 0) {
@@ -822,16 +1052,7 @@ async function handleAccountRoutes(req, res, url, context) {
         });
         return true;
       }
-      const rawBody = await new Promise((resolve4, reject) => {
-        let body = "";
-        req.setEncoding("utf8");
-        req.on("data", (chunk) => {
-          body += chunk;
-        });
-        req.on("end", () => resolve4(body));
-        req.on("error", reject);
-      });
-      const payload = asRecord(rawBody.length > 0 ? JSON.parse(rawBody) : {});
+      const payload = await readJsonBody(req);
       const accountId = typeof payload?.accountId === "string" ? payload.accountId.trim() : "";
       if (!accountId) {
         setJson(res, 400, { error: "account_not_found", message: "Missing accountId." });
@@ -915,16 +1136,7 @@ async function handleAccountRoutes(req, res, url, context) {
   }
   if (req.method === "POST" && url.pathname === "/codex-api/accounts/remove") {
     try {
-      const rawBody = await new Promise((resolve4, reject) => {
-        let body = "";
-        req.setEncoding("utf8");
-        req.on("data", (chunk) => {
-          body += chunk;
-        });
-        req.on("end", () => resolve4(body));
-        req.on("error", reject);
-      });
-      const payload = asRecord(rawBody.length > 0 ? JSON.parse(rawBody) : {});
+      const payload = await readJsonBody(req);
       const accountId = typeof payload?.accountId === "string" ? payload.accountId.trim() : "";
       if (!accountId) {
         setJson(res, 400, { error: "account_not_found", message: "Missing accountId." });
@@ -1721,6 +1933,47 @@ import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir3, tmpdir as tmpdir3 } from "os";
 import { join as join4 } from "path";
 import { writeFile as writeFile3 } from "fs/promises";
+
+// src/utils/commandInvocation.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { basename, extname } from "path";
+var WINDOWS_CMD_NAMES = /* @__PURE__ */ new Set(["codex", "npm", "npx"]);
+function quoteCmdExeArg(value) {
+  const normalized = value.replace(/"/g, '""');
+  if (!/[\s"]/u.test(normalized)) {
+    return normalized;
+  }
+  return `"${normalized}"`;
+}
+function needsCmdExeWrapper(command) {
+  if (process.platform !== "win32") {
+    return false;
+  }
+  const lowerCommand = command.toLowerCase();
+  const baseName = basename(lowerCommand);
+  if (/\.(cmd|bat)$/i.test(baseName)) {
+    return true;
+  }
+  if (extname(baseName)) {
+    return false;
+  }
+  return WINDOWS_CMD_NAMES.has(baseName);
+}
+function getSpawnInvocation(command, args = []) {
+  if (needsCmdExeWrapper(command)) {
+    return {
+      command: "cmd.exe",
+      args: ["/d", "/s", "/c", [quoteCmdExeArg(command), ...args.map((arg) => quoteCmdExeArg(arg))].join(" ")]
+    };
+  }
+  return { command, args };
+}
+function spawnSyncCommand(command, args = [], options = {}) {
+  const invocation = getSpawnInvocation(command, args);
+  return spawnSync2(invocation.command, invocation.args, options);
+}
+
+// src/server/skillsRoutes.ts
 function asRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
@@ -1795,10 +2048,13 @@ function getSkillsInstallDir() {
   return join4(getCodexHomeDir2(), "skills");
 }
 var DEFAULT_COMMAND_TIMEOUT_MS = 12e4;
+var SKILL_SEARCH_METADATA_LIMIT = 20;
+var SKILL_SEARCH_METADATA_CONCURRENCY = 4;
 async function runCommand2(command, args, options = {}) {
   const timeout = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
   await new Promise((resolve4, reject) => {
-    const proc = spawn3(command, args, {
+    const invocation = getSpawnInvocation(command, args);
+    const proc = spawn3(invocation.command, invocation.args, {
       cwd: options.cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1841,7 +2097,8 @@ async function runCommand2(command, args, options = {}) {
 async function runCommandWithOutput(command, args, options = {}) {
   const timeout = options.timeoutMs ?? DEFAULT_COMMAND_TIMEOUT_MS;
   return await new Promise((resolve4, reject) => {
-    const proc = spawn3(command, args, {
+    const invocation = getSpawnInvocation(command, args);
+    const proc = spawn3(invocation.command, invocation.args, {
       cwd: options.cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1911,6 +2168,17 @@ async function detectUserSkillsDir(appServer) {
   }
   return getSkillsInstallDir();
 }
+async function ensureInstalledSkillIsValid(appServer, skillPath) {
+  const result = await appServer.rpc("skills/list", { forceReload: true });
+  const normalized = skillPath.endsWith("/SKILL.md") ? skillPath : `${skillPath}/SKILL.md`;
+  for (const entry of result.data ?? []) {
+    for (const error of entry.errors ?? []) {
+      if (error.path === normalized) {
+        throw new Error(error.message || "Installed skill is invalid");
+      }
+    }
+  }
+}
 async function runGitFetchWithRefLockRetry(repoDir, args = ["fetch", "origin"]) {
   try {
     await runCommand2("git", args, { cwd: repoDir });
@@ -1927,11 +2195,18 @@ async function runGitFetchWithRefLockRetry(repoDir, args = ["fetch", "origin"])
     await runCommand2("git", args, { cwd: repoDir });
   }
 }
-function buildLocalHubEntry(info) {
+async function buildLocalHubEntry(info) {
+  let description = "";
+  if (info.path) {
+    try {
+      description = extractSkillDescriptionFromMarkdown(await readFile2(info.path, "utf8"));
+    } catch {
+    }
+  }
   return {
     name: info.name,
     owner: "local",
-    description: "",
+    description,
     displayName: "",
     publishedAt: 0,
     avatarUrl: "",
@@ -1941,6 +2216,143 @@ function buildLocalHubEntry(info) {
     enabled: info.enabled
   };
 }
+function stripAnsi(value) {
+  return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/gu, "");
+}
+function parseNpxSkillsFindOutput(output, installedMap) {
+  const lines = stripAnsi(output).split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+  const results = [];
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const match = line.match(/^(.+?@[^@\s]+)\s+([\d.]+[KMB]?)\s+installs$/iu);
+    if (!match) continue;
+    const source = match[1]?.trim() ?? "";
+    const installs = match[2]?.trim() ?? "";
+    const atIndex = source.lastIndexOf("@");
+    if (atIndex <= 0 || atIndex >= source.length - 1) continue;
+    const owner = source.slice(0, atIndex);
+    const name = source.slice(atIndex + 1);
+    let url = "";
+    const next = lines[index + 1] ?? "";
+    const urlMatch = next.match(/(?:^└\s*)?(https?:\/\/\S+)$/u);
+    if (urlMatch?.[1]) {
+      url = urlMatch[1];
+      index += 1;
+    }
+    const installedInfo = installedMap.get(name);
+    results.push({
+      name,
+      owner,
+      displayName: name,
+      description: installs ? `${installs} installs` : "",
+      installCountLabel: installs ? `${installs} installs` : "",
+      publishedAt: 0,
+      avatarUrl: "",
+      url,
+      installed: Boolean(installedInfo),
+      source,
+      path: installedInfo?.path,
+      enabled: installedInfo?.enabled
+    });
+  }
+  return results;
+}
+function parseGithubSkillSource(source) {
+  const atIndex = source.lastIndexOf("@");
+  if (atIndex <= 0 || atIndex >= source.length - 1) return null;
+  const ownerRepo = source.slice(0, atIndex).trim();
+  const skillName = source.slice(atIndex + 1).trim();
+  const ownerRepoParts = ownerRepo.split("/").filter(Boolean);
+  if (ownerRepoParts.length !== 2 || skillName.length === 0) return null;
+  if (ownerRepoParts.some((part) => part.includes(":") || part.includes(" "))) return null;
+  return { ownerRepo, skillName };
+}
+function getGithubOwnerAvatarUrl(source) {
+  const parsed = parseGithubSkillSource(source);
+  if (!parsed) return "";
+  const owner = parsed.ownerRepo.split("/")[0] ?? "";
+  return owner ? `https://github.com/${encodeURIComponent(owner)}.png?size=64` : "";
+}
+function buildGithubSkillRawCandidates(source) {
+  const parsed = parseGithubSkillSource(source);
+  if (!parsed) return [];
+  const ownerRepo = parsed.ownerRepo.split("/").map(encodeURIComponent).join("/");
+  const skillName = encodeURIComponent(parsed.skillName);
+  const branches = ["main", "master"];
+  const paths = [
+    `skills/${skillName}/SKILL.md`,
+    `${skillName}/SKILL.md`,
+    "SKILL.md"
+  ];
+  return branches.flatMap((branch) => paths.map((path) => `https://raw.githubusercontent.com/${ownerRepo}/${branch}/${path}`));
+}
+async function fetchTextWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, {
+      headers: { "User-Agent": "codex-web-local" },
+      signal: controller.signal
+    });
+    if (!resp.ok) return "";
+    return await resp.text();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function resolveSkillIconUrl(icon, markdownUrl) {
+  const value = icon.trim().replace(/^['"]|['"]$/gu, "");
+  if (!value) return "";
+  if (/^https?:\/\//iu.test(value)) return value;
+  try {
+    return new URL(value, markdownUrl).toString();
+  } catch {
+    return "";
+  }
+}
+async function fetchGithubSkillMetadata(source) {
+  for (const candidate of buildGithubSkillRawCandidates(source)) {
+    try {
+      const markdown = await fetchTextWithTimeout(candidate, 4e3);
+      if (!markdown) continue;
+      const description = extractSkillDescriptionFromMarkdown(markdown);
+      const icon = extractSkillFrontmatterField(markdown, "icon");
+      const avatarUrl = icon ? resolveSkillIconUrl(icon, candidate) : getGithubOwnerAvatarUrl(source);
+      if (description || avatarUrl) return { description, avatarUrl };
+    } catch {
+    }
+  }
+  return { avatarUrl: getGithubOwnerAvatarUrl(source) };
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  await Promise.all(Array.from({ length: workerCount }, async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await mapper(items[index], index);
+    }
+  }));
+  return results;
+}
+async function enrichSkillSearchDescriptions(results) {
+  const enrichedHead = await mapWithConcurrency(
+    results.slice(0, SKILL_SEARCH_METADATA_LIMIT),
+    SKILL_SEARCH_METADATA_CONCURRENCY,
+    async (result) => {
+      if (!result.source) return result;
+      const metadata = await fetchGithubSkillMetadata(result.source);
+      return {
+        ...result,
+        description: metadata.description || result.description,
+        avatarUrl: metadata.avatarUrl || result.avatarUrl
+      };
+    }
+  );
+  return [...enrichedHead, ...results.slice(SKILL_SEARCH_METADATA_LIMIT)];
+}
 function groupRpcSkillRecords(skills) {
   const normalizedPathSet = new Set(
     skills.map((skill) => normalizeSkillMarkdownPath(typeof skill.path === "string" ? skill.path : "")).filter(Boolean)
@@ -2027,7 +2439,40 @@ async function scanInstalledSkillsFromDisk() {
   }
   return map;
 }
+async function collectInstalledSkillsMap(appServer) {
+  const installedMap = await scanInstalledSkillsFromDisk();
+  try {
+    const result = await appServer.rpc("skills/list", {});
+    for (const entry of result.data ?? []) {
+      for (const skill of groupRpcSkillRecords(entry.skills ?? [])) {
+        if (skill.name) {
+          installedMap.set(skill.name, { name: skill.name, path: skill.path ?? "", enabled: skill.enabled !== false });
+        }
+      }
+    }
+  } catch {
+  }
+  return installedMap;
+}
+function extractSkillFrontmatterField(markdown, fieldName) {
+  const lines = markdown.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return "";
+  const frontmatter = [];
+  for (let index = 1; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (line.trim() === "---") break;
+    frontmatter.push(line);
+  }
+  const escapedFieldName = fieldName.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  const fieldPattern = new RegExp(`^${escapedFieldName}\\s*:`, "iu");
+  const valuePattern = new RegExp(`^${escapedFieldName}\\s*:\\s*`, "iu");
+  const fieldLine = frontmatter.find((line) => fieldPattern.test(line.trim()));
+  if (!fieldLine) return "";
+  return fieldLine.replace(valuePattern, "").replace(/^['"]|['"]$/gu, "").trim();
+}
 function extractSkillDescriptionFromMarkdown(markdown) {
+  const frontmatterDescription = extractSkillFrontmatterField(markdown, "description");
+  if (frontmatterDescription) return frontmatterDescription;
   const lines = markdown.split(/\r?\n/);
   let inCodeFence = false;
   for (const rawLine of lines) {
@@ -2229,6 +2674,7 @@ async function readRemoteSkillsManifest(token, repoOwner, repoName) {
 async function writeRemoteSkillsManifest(token, repoOwner, repoName, skills) {
   const url = `https://api.github.com/repos/${repoOwner}/${repoName}/contents/${SKILLS_SYNC_MANIFEST_PATH}`;
   let sha = "";
+  const nextContent = JSON.stringify(skills, null, 2);
   const existing = await fetch(url, {
     headers: {
       Accept: "application/vnd.github+json",
@@ -2240,13 +2686,16 @@ async function writeRemoteSkillsManifest(token, repoOwner, repoName, skills) {
   if (existing.ok) {
     const payload = await existing.json();
     sha = payload.sha ?? "";
+    const currentContent = payload.content ? Buffer.from(payload.content.replace(/\n/g, ""), "base64").toString("utf8") : "";
+    if (currentContent === nextContent) return false;
   }
-  const content = Buffer.from(JSON.stringify(skills, null, 2), "utf8").toString("base64");
+  const content = Buffer.from(nextContent, "utf8").toString("base64");
   await getGithubJson(url, token, "PUT", {
     message: "Update synced skills manifest",
     content,
     ...sha ? { sha } : {}
   });
+  return true;
 }
 function toGitHubTokenRemote(repoOwner, repoName, token) {
   return `https://x-access-token:${encodeURIComponent(token)}@github.com/${repoOwner}/${repoName}.git`;
@@ -2417,6 +2866,16 @@ async function hasLocalUncommittedChanges(repoDir) {
   const status = (await runCommandWithOutput("git", ["status", "--porcelain"], { cwd: repoDir })).trim();
   return status.length > 0;
 }
+async function hasCommittableWorkingTreeChanges(repoDir) {
+  try {
+    await runCommand2("git", ["diff", "--quiet", "--exit-code", "--ignore-submodules=dirty"], { cwd: repoDir });
+    await runCommand2("git", ["diff", "--cached", "--quiet", "--exit-code", "--ignore-submodules=dirty"], { cwd: repoDir });
+  } catch {
+    return true;
+  }
+  const untracked = (await runCommandWithOutput("git", ["ls-files", "--others", "--exclude-standard"], { cwd: repoDir })).trim();
+  return untracked.length > 0;
+}
 async function walkFileMtimes(rootDir, currentDir, out) {
   let entries;
   try {
@@ -2525,8 +2984,11 @@ async function syncInstalledSkillsFolderToRepo(token, repoOwner, repoName, _inst
   await runCommand2("git", ["config", "user.name", "Skills Sync"], { cwd: repoDir });
   await restoreProtectedFilesFromOrigin(repoDir, branch);
   await runCommand2("git", ["add", "."], { cwd: repoDir });
-  const status = (await runCommandWithOutput("git", ["status", "--porcelain"], { cwd: repoDir })).trim();
-  if (!status) return;
+  try {
+    await runCommand2("git", ["diff", "--cached", "--quiet", "--exit-code"], { cwd: repoDir });
+    return;
+  } catch {
+  }
   await runCommand2("git", ["commit", "-m", "Sync installed skills folder and manifest"], { cwd: repoDir });
   await pushWithNonFastForwardRetry(repoDir, branch);
 }
@@ -2572,8 +3034,8 @@ async function autoPushSyncedSkills(appServer) {
   await runCommand2("git", ["fetch", "origin", PRIVATE_SYNC_BRANCH], { cwd: repoDir });
   const head = (await runCommandWithOutput("git", ["rev-parse", "HEAD"], { cwd: repoDir })).trim();
   const originHead = (await runCommandWithOutput("git", ["rev-parse", `origin/${PRIVATE_SYNC_BRANCH}`], { cwd: repoDir })).trim();
-  const status = (await runCommandWithOutput("git", ["status", "--porcelain"], { cwd: repoDir })).trim();
-  if (!status && head === originHead) return;
+  const hasCommittableChanges = await hasCommittableWorkingTreeChanges(repoDir);
+  if (!hasCommittableChanges && head === originHead) return;
   const local = await collectLocalSyncedSkills(appServer);
   const installedMap = await scanInstalledSkillsFromDisk();
   await writeRemoteSkillsManifest(state.githubToken, state.repoOwner, state.repoName, local);
@@ -2689,25 +3151,11 @@ async function finalizeGithubLoginAndSync(token, username, appServer) {
   await autoPushSyncedSkills(appServer);
 }
 async function handleSkillsRoutes(req, res, url, context) {
-  const { appServer, readJsonBody: readJsonBody2 } = context;
+  const { appServer, readJsonBody: readJsonBody3 } = context;
   if (req.method === "GET" && url.pathname === "/codex-api/skills-hub") {
     try {
-      const installedMap = await scanInstalledSkillsFromDisk();
-      try {
-        const result = await appServer.rpc("skills/list", {});
-        for (const entry of result.data ?? []) {
-          for (const skill of groupRpcSkillRecords(entry.skills ?? [])) {
-            if (skill.name) {
-              installedMap.set(skill.name, { name: skill.name, path: skill.path ?? "", enabled: skill.enabled !== false });
-            }
-          }
-        }
-      } catch {
-      }
-      const installed = [];
-      for (const [, info] of installedMap) {
-        installed.push(buildLocalHubEntry(info));
-      }
+      const installedMap = await collectInstalledSkillsMap(appServer);
+      const installed = await Promise.all([...installedMap.values()].map((info) => buildLocalHubEntry(info)));
       installed.sort((a, b) => a.name.localeCompare(b.name));
       setJson3(res, 200, { installed });
     } catch (error) {
@@ -2715,6 +3163,22 @@ async function handleSkillsRoutes(req, res, url, context) {
     }
     return true;
   }
+  if (req.method === "GET" && url.pathname === "/codex-api/skills-hub/search") {
+    try {
+      const query = (url.searchParams.get("q") || "").trim();
+      if (query.length < 2) {
+        setJson3(res, 200, { results: [] });
+        return true;
+      }
+      const installedMap = await collectInstalledSkillsMap(appServer);
+      const output = await runCommandWithOutput("npx", ["--yes", "skills", "find", query], { timeoutMs: 6e4 });
+      const results = await enrichSkillSearchDescriptions(parseNpxSkillsFindOutput(output, installedMap));
+      setJson3(res, 200, { results });
+    } catch (error) {
+      setJson3(res, 502, { error: getErrorMessage3(error, "Failed to search skills") });
+    }
+    return true;
+  }
   if (req.method === "GET" && url.pathname === "/codex-api/skills-sync/status") {
     const state = await readSkillsSyncState();
     setJson3(res, 200, {
@@ -2755,7 +3219,7 @@ async function handleSkillsRoutes(req, res, url, context) {
   }
   if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/token-login") {
     try {
-      const payload = asRecord3(await readJsonBody2(req));
+      const payload = asRecord3(await readJsonBody3(req));
       const token = typeof payload?.token === "string" ? payload.token.trim() : "";
       if (!token) {
         setJson3(res, 400, { error: "Missing GitHub token" });
@@ -2787,7 +3251,7 @@ async function handleSkillsRoutes(req, res, url, context) {
   }
   if (req.method === "POST" && url.pathname === "/codex-api/skills-sync/github/complete-login") {
     try {
-      const payload = asRecord3(await readJsonBody2(req));
+      const payload = asRecord3(await readJsonBody3(req));
       const deviceCode = typeof payload?.deviceCode === "string" ? payload.deviceCode : "";
       if (!deviceCode) {
         setJson3(res, 400, { error: "Missing deviceCode" });
@@ -2819,7 +3283,7 @@ async function handleSkillsRoutes(req, res, url, context) {
         return true;
       }
       const local = await collectLocalSyncedSkills(appServer);
-      const installedMap = await scanInstalledSkillsFromDisk();
+      const installedMap = await collectInstalledSkillsMap(appServer);
       await writeRemoteSkillsManifest(state.githubToken, state.repoOwner, state.repoName, local);
       await syncInstalledSkillsFolderToRepo(state.githubToken, state.repoOwner, state.repoName, installedMap);
       setJson3(res, 200, { ok: true, data: { synced: local.length } });
@@ -2925,12 +3389,38 @@ async function handleSkillsRoutes(req, res, url, context) {
     return true;
   }
   if (req.method === "POST" && url.pathname === "/codex-api/skills-hub/install") {
-    setJson3(res, 410, { error: "Remote Skills Hub installation is disabled." });
+    try {
+      const payload = asRecord3(await readJsonBody3(req));
+      const source = typeof payload?.source === "string" ? payload.source.trim() : "";
+      const owner = typeof payload?.owner === "string" ? payload.owner.trim() : "";
+      const name = typeof payload?.name === "string" ? payload.name.trim() : "";
+      const installSource = source || (owner && name ? `${owner}@${name}` : "");
+      if (!installSource || !/^[A-Za-z0-9._/-]+@[A-Za-z0-9._-]+$/u.test(installSource)) {
+        setJson3(res, 400, { error: "Missing or invalid skill source" });
+        return true;
+      }
+      await runCommand2("npx", ["--yes", "skills", "add", installSource, "--yes", "--global"], { timeoutMs: 12e4 });
+      try {
+        await withTimeout(appServer.rpc("skills/list", { forceReload: true }), 1e4, "skills/list reload");
+      } catch {
+      }
+      const installedMap = await collectInstalledSkillsMap(appServer);
+      const installed = installedMap.get(name || installSource.slice(installSource.lastIndexOf("@") + 1));
+      if (!installed?.path) {
+        throw new Error(`Skill install completed but ${installSource} was not found in local installed skills`);
+      }
+      await ensureInstalledSkillIsValid(appServer, installed.path);
+      autoPushSyncedSkills(appServer).catch(() => {
+      });
+      setJson3(res, 200, { ok: true, path: installed.path });
+    } catch (error) {
+      setJson3(res, 502, { error: getErrorMessage3(error, "Failed to install skill") });
+    }
     return true;
   }
   if (req.method === "POST" && url.pathname === "/codex-api/skills-hub/uninstall") {
     try {
-      const payload = asRecord3(await readJsonBody2(req));
+      const payload = asRecord3(await readJsonBody3(req));
       const name = typeof payload?.name === "string" ? payload.name : "";
       const path = typeof payload?.path === "string" ? payload.path : "";
       const normalizedPath = path.endsWith("/SKILL.md") ? path.slice(0, -"/SKILL.md".length) : path;
@@ -2962,7 +3452,7 @@ async function handleSkillsRoutes(req, res, url, context) {
 }
 
 // src/server/telegramThreadBridge.ts
-import { basename } from "path";
+import { basename as basename2 } from "path";
 var TELEGRAM_MESSAGE_MAX_LENGTH = 3500;
 var TELEGRAM_BOT_COMMANDS = [
   { command: "start", description: "Show quick start and thread picker" },
@@ -3448,7 +3938,7 @@ Add this ID to the bot allowlist before using the bridge.`;
       const name = typeof record?.name === "string" ? record.name.trim() : "";
       const preview = typeof record?.preview === "string" ? record.preview.trim() : "";
       const cwd = typeof record?.cwd === "string" ? record.cwd.trim() : "";
-      const projectName = cwd ? basename(cwd) : "project";
+      const projectName = cwd ? basename2(cwd) : "project";
       const threadTitle = (name || preview || id).replace(/\s+/g, " ").trim();
       const title = `${projectName}/${threadTitle}`.slice(0, 64);
       threads.push({ id, title });
@@ -3675,6 +4165,7 @@ var FALLBACK_FREE_MODELS = [
 var cachedFreeModels = null;
 var cacheTimestamp = 0;
 var CACHE_TTL_MS = 10 * 60 * 1e3;
+var freeModelsRefreshPromise = null;
 async function fetchFreeModelsFromOpenRouter() {
   try {
     const resp = await fetch("https://openrouter.ai/api/v1/models");
@@ -3696,11 +4187,36 @@ async function getFreeModels() {
   }
   return fetchFreeModelsFromOpenRouter();
 }
+function getCachedFreeModels() {
+  return cachedFreeModels ?? FALLBACK_FREE_MODELS;
+}
+function refreshFreeModelsInBackground() {
+  if (cachedFreeModels && Date.now() - cacheTimestamp < CACHE_TTL_MS) return;
+  if (freeModelsRefreshPromise) return;
+  freeModelsRefreshPromise = fetchFreeModelsFromOpenRouter().finally(() => {
+    freeModelsRefreshPromise = null;
+  });
+}
 var FREE_MODE_DEFAULT_MODEL = "openrouter/free";
 var FREE_MODE_STATE_FILE = "webui-free-mode.json";
 var CUSTOM_PROVIDER_ID = "custom-endpoint";
 var OPENCODE_ZEN_PROVIDER_ID = "opencode-zen";
 var OPENCODE_ZEN_BASE_URL = "https://opencode.ai/zen/v1";
+var OPENCODE_ZEN_DEFAULT_MODEL = "big-pickle";
+function createDefaultOpenCodeZenFreeModeState() {
+  return {
+    enabled: true,
+    apiKey: null,
+    model: OPENCODE_ZEN_DEFAULT_MODEL,
+    customKey: false,
+    provider: "opencode-zen",
+    wireApi: "chat",
+    providerKeys: {}
+  };
+}
+function shouldCreateDefaultFreeModeStateForMissingAuth(current, hasUsableCodexAuth) {
+  return current == null && !hasUsableCodexAuth;
+}
 function getFreeModeEnvVars(state) {
   if (!state.enabled) return {};
   if (state.provider === "opencode-zen" && state.apiKey) {
@@ -3717,7 +4233,9 @@ function getFreeModeConfigArgs(state, serverPort) {
     const baseUrl2 = serverPort ? `http://127.0.0.1:${serverPort}/codex-api/zen-proxy/v1` : OPENCODE_ZEN_BASE_URL;
     const wireApi = serverPort ? "responses" : state.wireApi || "chat";
     const authArgs = serverPort ? ["-c", `model_providers.${OPENCODE_ZEN_PROVIDER_ID}.experimental_bearer_token="zen-proxy-token"`] : ["-c", `model_providers.${OPENCODE_ZEN_PROVIDER_ID}.env_key="OPENCODE_ZEN_API_KEY"`];
+    const modelArgs = state.model?.trim() ? ["-c", `model="${state.model.trim()}"`] : [];
     return [
+      ...modelArgs,
       "-c",
       `model_provider="${OPENCODE_ZEN_PROVIDER_ID}"`,
       "-c",
@@ -3785,27 +4303,52 @@ function safeStringifyUnknown(value) {
     return String(value ?? "");
   }
 }
-function appendAssistantText(messages, text) {
+function appendAssistantText(messages, text, reasoningContent) {
   const trimmedText = text.trim();
-  if (!trimmedText) return;
+  const trimmedReasoningContent = reasoningContent?.trim() ?? "";
+  if (!trimmedText && !trimmedReasoningContent) return;
   const lastMessage = messages[messages.length - 1];
   if (lastMessage?.role === "assistant" && Array.isArray(lastMessage.tool_calls)) {
     lastMessage.content = lastMessage.content ? `${lastMessage.content}
 ${trimmedText}` : trimmedText;
+    if (trimmedReasoningContent) {
+      lastMessage.reasoning_content = lastMessage.reasoning_content ? `${lastMessage.reasoning_content}
+${trimmedReasoningContent}` : trimmedReasoningContent;
+    }
     return;
   }
-  messages.push({ role: "assistant", content: trimmedText });
+  messages.push({
+    role: "assistant",
+    content: trimmedText,
+    ...trimmedReasoningContent ? { reasoning_content: trimmedReasoningContent } : {}
+  });
 }
-function appendAssistantToolCall(messages, toolCall) {
+function appendAssistantToolCall(messages, toolCall, reasoningContent) {
+  const trimmedReasoningContent = reasoningContent?.trim() ?? "";
   const lastMessage = messages[messages.length - 1];
   if (lastMessage?.role === "assistant" && !lastMessage.tool_call_id) {
     lastMessage.tool_calls = [...lastMessage.tool_calls ?? [], toolCall];
+    if (trimmedReasoningContent) {
+      lastMessage.reasoning_content = lastMessage.reasoning_content ? `${lastMessage.reasoning_content}
+${trimmedReasoningContent}` : trimmedReasoningContent;
+    }
     return;
   }
-  messages.push({ role: "assistant", tool_calls: [toolCall] });
+  messages.push({
+    role: "assistant",
+    content: "",
+    tool_calls: [toolCall],
+    ...trimmedReasoningContent ? { reasoning_content: trimmedReasoningContent } : {}
+  });
+}
+function extractTextParts(value) {
+  if (typeof value === "string") return value;
+  if (!Array.isArray(value)) return "";
+  return value.map((part) => part && typeof part === "object" && typeof part.text === "string" ? part.text : "").filter((part) => part.length > 0).join("\n");
 }
 function responsesInputToMessages(input, instructions) {
   const messages = [];
+  let pendingReasoningContent = "";
   if (instructions) {
     messages.push({ role: "system", content: instructions });
   }
@@ -3815,12 +4358,29 @@ function responsesInputToMessages(input, instructions) {
   }
   for (const item of input) {
     if (!item || typeof item !== "object") continue;
+    if (item.type === "reasoning") {
+      const content = extractTextParts(item.content);
+      const summary = extractTextParts(item.summary);
+      const text = content || summary;
+      if (text) {
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage?.role === "assistant") {
+          lastMessage.reasoning_content = lastMessage.reasoning_content ? `${lastMessage.reasoning_content}
+${text}` : text;
+        } else {
+          pendingReasoningContent = pendingReasoningContent ? `${pendingReasoningContent}
+${text}` : text;
+        }
+      }
+      continue;
+    }
     if (item.type === "message" && item.role) {
       const content = item.content;
       const text = typeof content === "string" ? content : Array.isArray(content) ? content.map((part) => typeof part?.text === "string" ? part.text : "").filter((part) => part.length > 0).join("\n") : typeof item.text === "string" ? item.text : "";
       const role = item.role === "developer" ? "system" : item.role;
       if (role === "assistant") {
-        appendAssistantText(messages, text);
+        appendAssistantText(messages, text, pendingReasoningContent);
+        pendingReasoningContent = "";
       } else {
         messages.push({ role, content: text });
       }
@@ -3842,7 +4402,8 @@ function responsesInputToMessages(input, instructions) {
           name: item.name,
           arguments: typeof item.arguments === "string" ? item.arguments : "{}"
         }
-      });
+      }, pendingReasoningContent);
+      pendingReasoningContent = "";
     }
   }
   return messages;
@@ -3905,6 +4466,14 @@ function chatCompletionToResponsesFormat(chatResponse, model) {
         status: "completed"
       });
     }
+    if (message.reasoning_content) {
+      output.push({
+        type: "reasoning",
+        id: `rs_${Date.now()}`,
+        summary: [],
+        content: [{ type: "reasoning_text", text: message.reasoning_content }]
+      });
+    }
   }
   const usage = chatResponse.usage;
   return {
@@ -3929,6 +4498,7 @@ function forwardStreamingTextResponse(upstreamRes, res, model) {
   });
   let buffer = "";
   const contentParts = [];
+  const reasoningParts = [];
   let responseId = `resp_${Date.now()}`;
   res.write(`data: {"type":"response.created","response":{"id":"${responseId}","object":"response","status":"in_progress","model":"${model}","output":[]}}
 
@@ -3947,6 +4517,9 @@ function forwardStreamingTextResponse(upstreamRes, res, model) {
         const parsed = JSON.parse(data);
         if (parsed.id) responseId = `resp_${parsed.id}`;
         const delta = parsed.choices?.[0]?.delta;
+        if (delta?.reasoning_content) {
+          reasoningParts.push(delta.reasoning_content);
+        }
         if (delta?.content) {
           contentParts.push(delta.content);
           const escaped = JSON.stringify(delta.content).slice(1, -1);
@@ -3960,7 +4533,18 @@ function forwardStreamingTextResponse(upstreamRes, res, model) {
   });
   upstreamRes.on("end", () => {
     const fullText = contentParts.join("");
+    const fullReasoningText = reasoningParts.join("");
     const escapedFull = JSON.stringify(fullText).slice(1, -1);
+    const messageItem = { type: "message", role: "assistant", content: [{ type: "output_text", text: fullText }], status: "completed" };
+    const output = [messageItem];
+    if (fullReasoningText) {
+      output.push({
+        type: "reasoning",
+        id: `rs_${Date.now()}`,
+        summary: [],
+        content: [{ type: "reasoning_text", text: fullReasoningText }]
+      });
+    }
     res.write(`data: {"type":"response.output_text.done","output_index":0,"content_index":0,"text":"${escapedFull}"}
 
 `);
@@ -3970,7 +4554,17 @@ function forwardStreamingTextResponse(upstreamRes, res, model) {
     res.write(`data: {"type":"response.output_item.done","output_index":0,"item":{"type":"message","role":"assistant","content":[{"type":"output_text","text":"${escapedFull}"}],"status":"completed"}}
 
 `);
-    res.write(`data: {"type":"response.completed","response":{"id":"${responseId}","object":"response","status":"completed","model":"${model}","output":[{"type":"message","role":"assistant","content":[{"type":"output_text","text":"${escapedFull}"}],"status":"completed"}]}}
+    if (fullReasoningText) {
+      const reasoningIndex = output.length - 1;
+      const reasoningItem = output[reasoningIndex];
+      res.write(`data: ${JSON.stringify({ type: "response.output_item.added", output_index: reasoningIndex, item: reasoningItem })}
+
+`);
+      res.write(`data: ${JSON.stringify({ type: "response.output_item.done", output_index: reasoningIndex, item: reasoningItem })}
+
+`);
+    }
+    res.write(`data: ${JSON.stringify({ type: "response.completed", response: { id: responseId, object: "response", status: "completed", model, output } })}
 
 `);
     res.end();
@@ -4042,7 +4636,7 @@ function hasToolOutputsInInput(input) {
 function handleUnifiedResponsesProxyRequest(req, res, options) {
   void (async () => {
     try {
-      if (!options.bearerToken) {
+      if (options.requireBearerToken !== false && !options.bearerToken) {
         res.writeHead(401, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ error: { message: options.missingKeyMessage } }));
         return;
@@ -4055,14 +4649,14 @@ function handleUnifiedResponsesProxyRequest(req, res, options) {
       const useChatCompletions = options.wireApi === "chat" && !useResponsesFallback;
       const useChatPayload = useChatCompletions || options.responsesPayloadFormat === "chat";
       const isStreaming = parsedBody.stream === true;
-      const effectiveStreaming = useChatCompletions && isStreaming && !(hasTools || hasToolOutputs);
+      const effectiveStreaming = useChatPayload && isStreaming && !(hasTools || hasToolOutputs);
       let payload = "";
       let upstreamUrl;
       if (useChatPayload) {
         const chatReq = {
           model: parsedBody.model,
           messages: responsesInputToMessages(parsedBody.input, parsedBody.instructions),
-          stream: useChatCompletions ? effectiveStreaming : isStreaming
+          stream: effectiveStreaming
         };
         if (parsedBody.temperature != null) chatReq.temperature = parsedBody.temperature;
         if (parsedBody.top_p != null) chatReq.top_p = parsedBody.top_p;
@@ -4072,7 +4666,7 @@ function handleUnifiedResponsesProxyRequest(req, res, options) {
         if (chatTools) chatReq.tools = chatTools;
         if (chatToolChoice) chatReq.tool_choice = chatToolChoice;
         payload = JSON.stringify(chatReq);
-        upstreamUrl = new URL(useChatCompletions ? options.chatCompletionsEndpoint : options.responsesEndpoint);
+        upstreamUrl = new URL(options.chatCompletionsEndpoint);
       } else {
         const requestBody = parsedBody && typeof parsedBody === "object" && !Array.isArray(parsedBody) ? { ...parsedBody } : {};
         const sanitized = options.sanitizeResponsesRequest ? options.sanitizeResponsesRequest(requestBody) : requestBody;
@@ -4088,11 +4682,11 @@ function handleUnifiedResponsesProxyRequest(req, res, options) {
         headers: {
           "Content-Type": "application/json",
           "Content-Length": Buffer.byteLength(payload),
-          "Authorization": `Bearer ${options.bearerToken}`
+          ...options.bearerToken ? { "Authorization": `Bearer ${options.bearerToken}` } : {}
         }
       }, (upstreamRes) => {
         const status = upstreamRes.statusCode ?? 502;
-        if (useChatCompletions && effectiveStreaming && status >= 200 && status < 300) {
+        if (useChatPayload && effectiveStreaming && status >= 200 && status < 300) {
           forwardStreamingTextResponse(upstreamRes, res, parsedBody.model);
           return;
         }
@@ -4100,7 +4694,7 @@ function handleUnifiedResponsesProxyRequest(req, res, options) {
         upstreamRes.on("data", (chunk) => chunks.push(chunk));
         upstreamRes.on("end", () => {
           const rawResponseBody = Buffer.concat(chunks).toString();
-          if (!useChatCompletions) {
+          if (!useChatPayload) {
             res.writeHead(status, copyProxyHeaders(upstreamRes.headers));
             res.end(rawResponseBody);
             return;
@@ -4108,6 +4702,14 @@ function handleUnifiedResponsesProxyRequest(req, res, options) {
           try {
             const upstreamPayload = JSON.parse(rawResponseBody);
             if (upstreamPayload.error || status >= 400) {
+              if (process.env.CODEXUI_PROXY_DEBUG === "1") {
+                console.warn("[unified-responses-proxy]", JSON.stringify({
+                  status,
+                  upstreamUrl: upstreamUrl.toString(),
+                  request: JSON.parse(payload),
+                  response: upstreamPayload
+                }));
+              }
               res.writeHead(status, { "Content-Type": "application/json" });
               res.end(JSON.stringify(upstreamPayload));
               return;
@@ -4193,6 +4795,7 @@ function handleZenProxyRequest(req, res, bearerToken, wireApi) {
     responsesEndpoint: ZEN_RESPONSES_ENDPOINT,
     chatCompletionsEndpoint: ZEN_CHAT_COMPLETIONS_ENDPOINT,
     missingKeyMessage: "Missing OpenCode Zen API key",
+    requireBearerToken: false,
     allowToolFallbackToResponses: false,
     responsesPayloadFormat: "chat"
   });
@@ -4217,9 +4820,9 @@ function handleCustomEndpointProxyRequest(req, res, options) {
 import { chmodSync, existsSync as existsSync3, lstatSync, readFileSync, realpathSync, rmSync, writeFileSync } from "fs";
 import { randomUUID } from "crypto";
 import { createRequire } from "module";
-import { basename as basename2, dirname, join as join5 } from "path";
+import { basename as basename3, dirname, join as join5 } from "path";
 import { homedir as homedir4 } from "os";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync as spawnSync3 } from "child_process";
 var TERMINAL_BUFFER_LIMIT = 16 * 1024;
 var DEFAULT_COLS = 80;
 var DEFAULT_ROWS = 24;
@@ -4352,7 +4955,7 @@ var ThreadTerminalManager = class {
       id: params.sessionId,
       threadId: params.threadId,
       cwd,
-      shell: basename2(shell),
+      shell: basename3(shell),
       pty,
       buffer: "",
       truncated: false
@@ -4492,7 +5095,6 @@ function normalizeDimension(value, fallback) {
   return Math.max(1, Math.min(500, Math.trunc(parsed)));
 }
 function loadTerminalSpawn() {
-  repairNativePtyBuild("node-pty-prebuilt-multiarch");
   repairNativePtyBuild("node-pty");
   if (resolveNodePtyPrebuiltPath()) {
     try {
@@ -4522,7 +5124,7 @@ function repairNativePtyBuild(packageName) {
       writeFileSync(makefile, patched);
     }
     rmSync(binary, { force: true });
-    spawnSync2("make", ["BUILDTYPE=Release", "-C", buildDir], { stdio: "ignore" });
+    spawnSync3("make", ["BUILDTYPE=Release", "-C", buildDir], { stdio: "ignore" });
   } catch {
   }
 }
@@ -4557,9 +5159,12 @@ function resolveNodePtyPrebuiltPath() {
 }
 function ensureNodePtyPrebuiltExecutable() {
   if (process.platform !== "darwin" && process.platform !== "linux") return;
+  ensurePackageSpawnHelperExecutable("node-pty");
+  ensurePackageSpawnHelperExecutable("node-pty-prebuilt-multiarch");
+}
+function ensurePackageSpawnHelperExecutable(packageName) {
   try {
-    const nodePtyEntry = require2.resolve("node-pty-prebuilt-multiarch");
-    const packageRoot = join5(dirname(nodePtyEntry), "..");
+    const packageRoot = dirname(require2.resolve(`${packageName}/package.json`));
     const helperPath = join5(packageRoot, "prebuilds", `${process.platform}-${process.arch}`, "spawn-helper");
     if (existsSync3(helperPath)) {
       chmodSync(helperPath, 493);
@@ -4577,45 +5182,6 @@ function shellQuote(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 
-// src/utils/commandInvocation.ts
-import { spawnSync as spawnSync3 } from "child_process";
-import { basename as basename3, extname } from "path";
-var WINDOWS_CMD_NAMES = /* @__PURE__ */ new Set(["codex", "npm", "npx"]);
-function quoteCmdExeArg(value) {
-  const normalized = value.replace(/"/g, '""');
-  if (!/[\s"]/u.test(normalized)) {
-    return normalized;
-  }
-  return `"${normalized}"`;
-}
-function needsCmdExeWrapper(command) {
-  if (process.platform !== "win32") {
-    return false;
-  }
-  const lowerCommand = command.toLowerCase();
-  const baseName = basename3(lowerCommand);
-  if (/\.(cmd|bat)$/i.test(baseName)) {
-    return true;
-  }
-  if (extname(baseName)) {
-    return false;
-  }
-  return WINDOWS_CMD_NAMES.has(baseName);
-}
-function getSpawnInvocation(command, args = []) {
-  if (needsCmdExeWrapper(command)) {
-    return {
-      command: "cmd.exe",
-      args: ["/d", "/s", "/c", [quoteCmdExeArg(command), ...args.map((arg) => quoteCmdExeArg(arg))].join(" ")]
-    };
-  }
-  return { command, args };
-}
-function spawnSyncCommand(command, args = [], options = {}) {
-  const invocation = getSpawnInvocation(command, args);
-  return spawnSync3(invocation.command, invocation.args, options);
-}
-
 // src/server/codexAppServerBridge.ts
 var COMPOSIO_CONNECTORS_PAGE_LIMIT_MAX = 1e3;
 var PROVIDER_MODELS_FETCH_TIMEOUT_MS = 5e3;
@@ -4631,6 +5197,152 @@ var DEFAULT_API_PERF_MS_THRESHOLD = 300;
 var DEFAULT_API_PERF_BODY_MB_THRESHOLD = 1;
 var MB_DIVISOR = 1024 * 1024;
 var COMPOSIO_USER_DATA_PATH = join6(homedir5(), ".composio", "user_data.json");
+var SESSION_SKILL_INPUT_CACHE_LIMIT = 64;
+var sessionSkillInputCache = /* @__PURE__ */ new Map();
+function parseSessionSkillText(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("<skill>")) return null;
+  const name = trimmed.match(/<name>\s*([\s\S]*?)\s*<\/name>/u)?.[1]?.trim() ?? "";
+  const path = trimmed.match(/<path>\s*([\s\S]*?)\s*<\/path>/u)?.[1]?.trim() ?? "";
+  if (!name || !path) return null;
+  return { name, path };
+}
+function buildSessionSkillInputsByTurn(sessionLogRaw) {
+  let currentTurnId = "";
+  const skillsByTurnId = /* @__PURE__ */ new Map();
+  for (const line of sessionLogRaw.split("\n")) {
+    if (!line.trim()) continue;
+    let row = null;
+    try {
+      row = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (row.type === "turn_context") {
+      const payloadRecord2 = asRecord5(row.payload);
+      currentTurnId = readNonEmptyString(payloadRecord2?.turn_id) || currentTurnId;
+      continue;
+    }
+    if (row.type === "event_msg") {
+      const payloadRecord2 = asRecord5(row.payload);
+      if (payloadRecord2?.type === "task_started") {
+        currentTurnId = readNonEmptyString(payloadRecord2.turn_id) || currentTurnId;
+      }
+      continue;
+    }
+    if (row.type !== "response_item" || !currentTurnId) continue;
+    const payloadRecord = asRecord5(row.payload);
+    if (payloadRecord?.type !== "message" || payloadRecord.role !== "user") continue;
+    const content = Array.isArray(payloadRecord.content) ? payloadRecord.content : [];
+    for (const contentItem of content) {
+      const contentRecord = asRecord5(contentItem);
+      if (contentRecord?.type !== "input_text" || typeof contentRecord.text !== "string") continue;
+      const skill = parseSessionSkillText(contentRecord.text);
+      if (!skill) continue;
+      const existing = skillsByTurnId.get(currentTurnId) ?? [];
+      if (!existing.some((item) => item.path === skill.path)) {
+        existing.push(skill);
+        skillsByTurnId.set(currentTurnId, existing);
+      }
+    }
+  }
+  return skillsByTurnId;
+}
+async function readCachedSessionSkillInputsByTurn(sessionPath) {
+  const sessionStat = await stat4(sessionPath);
+  const cached = sessionSkillInputCache.get(sessionPath);
+  if (cached && cached.size === sessionStat.size && cached.mtimeMs === sessionStat.mtimeMs) {
+    return cached.skillsByTurnId;
+  }
+  const sessionLogRaw = await readFile3(sessionPath, "utf8");
+  const skillsByTurnId = buildSessionSkillInputsByTurn(sessionLogRaw);
+  sessionSkillInputCache.set(sessionPath, {
+    size: sessionStat.size,
+    mtimeMs: sessionStat.mtimeMs,
+    skillsByTurnId
+  });
+  if (sessionSkillInputCache.size > SESSION_SKILL_INPUT_CACHE_LIMIT) {
+    const oldestKey = sessionSkillInputCache.keys().next().value;
+    if (oldestKey) sessionSkillInputCache.delete(oldestKey);
+  }
+  return skillsByTurnId;
+}
+function mergeSessionSkillInputsIntoTurnsFromMap(turns, skillsByTurnId) {
+  const turnIds = /* @__PURE__ */ new Set();
+  for (const turn of turns) {
+    const turnRecord = asRecord5(turn);
+    const turnId = readNonEmptyString(turnRecord?.id);
+    if (turnId) turnIds.add(turnId);
+  }
+  if (turnIds.size === 0) return turns;
+  if (skillsByTurnId.size === 0) return turns;
+  let changed = false;
+  const nextTurns = turns.map((turn) => {
+    const turnRecord = asRecord5(turn);
+    const turnId = readNonEmptyString(turnRecord?.id);
+    const skills = turnId ? skillsByTurnId.get(turnId) : void 0;
+    const items = Array.isArray(turnRecord?.items) ? turnRecord.items : null;
+    if (!turnRecord || !skills || skills.length === 0 || !items) return turn;
+    let targetUserMessageIndex = -1;
+    for (let index = items.length - 1; index >= 0; index -= 1) {
+      const itemRecord = asRecord5(items[index]);
+      if (itemRecord?.type === "userMessage" && Array.isArray(itemRecord.content)) {
+        targetUserMessageIndex = index;
+        break;
+      }
+    }
+    if (targetUserMessageIndex < 0) return turn;
+    let addedToMessage = false;
+    const nextItems = items.map((item, index) => {
+      const itemRecord = asRecord5(item);
+      const content = Array.isArray(itemRecord?.content) ? itemRecord.content : null;
+      if (index !== targetUserMessageIndex || itemRecord?.type !== "userMessage" || !content) return item;
+      const existingSkillPaths = new Set(
+        content.flatMap((contentItem) => {
+          const contentRecord = asRecord5(contentItem);
+          const path = typeof contentRecord?.path === "string" ? contentRecord.path.trim() : "";
+          return contentRecord?.type === "skill" && path ? [path] : [];
+        })
+      );
+      const missingSkills = skills.filter((skill) => !existingSkillPaths.has(skill.path));
+      if (missingSkills.length === 0) return item;
+      addedToMessage = true;
+      changed = true;
+      return {
+        ...itemRecord,
+        content: [
+          ...content,
+          ...missingSkills.map((skill) => ({ type: "skill", name: skill.name, path: skill.path }))
+        ]
+      };
+    });
+    return addedToMessage ? { ...turnRecord, items: nextItems } : turn;
+  });
+  return changed ? nextTurns : turns;
+}
+async function mergeSessionSkillInputsIntoThreadResult(result) {
+  const record = asRecord5(result);
+  const thread = asRecord5(record?.thread);
+  const turns = Array.isArray(thread?.turns) ? thread.turns : null;
+  const sessionPath = readNonEmptyString(thread?.path);
+  if (!record || !thread || !turns || turns.length === 0 || !sessionPath || !isAbsolute2(sessionPath)) {
+    return result;
+  }
+  try {
+    const skillsByTurnId = await readCachedSessionSkillInputsByTurn(sessionPath);
+    const mergedTurns = mergeSessionSkillInputsIntoTurnsFromMap(turns, skillsByTurnId);
+    if (mergedTurns === turns) return result;
+    return {
+      ...record,
+      thread: {
+        ...thread,
+        turns: mergedTurns
+      }
+    };
+  } catch {
+    return result;
+  }
+}
 function readEnvValueFromFile(filePath, key) {
   try {
     const content = readFileSync2(filePath, "utf8");
@@ -5247,6 +5959,48 @@ function extractThreadMessageText(threadReadPayload) {
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : "";
 }
+function readThreadArchiveFallbackName(threadReadResult) {
+  const record = asRecord5(threadReadResult);
+  const thread = asRecord5(record?.thread);
+  return readNonEmptyString(thread?.name) || readNonEmptyString(thread?.title) || readNonEmptyString(thread?.preview) || "Untitled thread";
+}
+function isArchivedThreadReadResult(threadReadResult) {
+  const record = asRecord5(threadReadResult);
+  const thread = asRecord5(record?.thread);
+  const sessionPath = readNonEmptyString(thread?.path);
+  return sessionPath.split(/[\\/]+/u).includes("archived_sessions");
+}
+async function callRpcWithArchiveRecovery(appServer, method, params) {
+  try {
+    return await appServer.rpc(method, params ?? null);
+  } catch (error) {
+    if (method !== "thread/archive") {
+      throw error;
+    }
+    const paramsRecord = asRecord5(params);
+    const threadId = readNonEmptyString(paramsRecord?.threadId);
+    const errorMessage = getErrorMessage5(error, "");
+    if (!threadId || !errorMessage.includes("no rollout found")) {
+      throw error;
+    }
+    let threadReadResult = null;
+    try {
+      threadReadResult = await appServer.rpc("thread/read", {
+        threadId,
+        includeTurns: false
+      });
+      if (isArchivedThreadReadResult(threadReadResult)) {
+        return null;
+      }
+    } catch {
+    }
+    await appServer.rpc("thread/name/set", {
+      threadId,
+      name: readThreadArchiveFallbackName(threadReadResult)
+    });
+    return appServer.rpc(method, params ?? null);
+  }
+}
 async function listTerminalQuickCommands(cwd) {
   const normalizedCwd = isAbsolute2(cwd) ? cwd : resolve2(cwd);
   const info = await stat4(normalizedCwd);
@@ -5350,26 +6104,53 @@ function readBoolean2(value) {
 function readNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
-function resolveComposioCommand() {
+function buildComposioInvocation(args) {
+  const overrideCommand = process.env.CODEXUI_COMPOSIO_COMMAND?.trim();
+  if (overrideCommand) {
+    const invocation = getSpawnInvocation(overrideCommand, args);
+    return {
+      command: invocation.command,
+      args: invocation.args,
+      displayCommand: `${overrideCommand} ${args.map(quoteShellTokenIfNeeded).join(" ")}`.trim()
+    };
+  }
+  return buildInstalledComposioInvocation(args);
+}
+function buildInstalledComposioInvocation(args) {
   const candidates = [
-    process.env.CODEXUI_COMPOSIO_COMMAND?.trim() ?? "",
     join6(homedir5(), ".composio", "composio"),
     "composio"
   ];
   for (const candidate of candidates) {
-    if (!candidate) continue;
     if ((candidate.includes("/") || candidate.includes("\\")) && !existsSync4(candidate)) continue;
-    const invocation = getSpawnInvocation(candidate, ["--version"]);
-    const probe = spawnSync4(invocation.command, invocation.args, {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    if (!probe.error && probe.status === 0) {
-      return candidate;
-    }
+    const invocation = getSpawnInvocation(candidate, args);
+    return {
+      command: invocation.command,
+      args: invocation.args,
+      displayCommand: `${candidate} ${args.map(quoteShellTokenIfNeeded).join(" ")}`.trim()
+    };
   }
   return null;
 }
+function probeComposioInvocation(invocation) {
+  const probe = spawnSync4(invocation.command, invocation.args, {
+    encoding: "utf8",
+    env: process.env,
+    windowsHide: true
+  });
+  const output = `${probe.stdout ?? ""}${probe.stderr ?? ""}`.trim();
+  return {
+    available: !probe.error && probe.status === 0,
+    cliVersion: probe.status === 0 ? (probe.stdout ?? "").trim() : "",
+    output
+  };
+}
+function resolveComposioInvocation(args) {
+  const invocation = buildComposioInvocation(args);
+  const versionInvocation = buildComposioInvocation(["--version"]);
+  if (invocation && versionInvocation && probeComposioInvocation(versionInvocation).available) return invocation;
+  return null;
+}
 function parseComposioJson(stdout, fallback) {
   const trimmed = stdout.trim();
   if (!trimmed) {
@@ -5378,11 +6159,10 @@ function parseComposioJson(stdout, fallback) {
   return JSON.parse(trimmed);
 }
 async function runComposioJson(args, fallback) {
-  const command = resolveComposioCommand();
-  if (!command) {
+  const invocation = resolveComposioInvocation(args);
+  if (!invocation) {
     throw new Error("Composio CLI is not installed");
   }
-  const invocation = getSpawnInvocation(command, args);
   const child = spawn4(invocation.command, invocation.args, {
     env: process.env,
     stdio: ["ignore", "pipe", "pipe"],
@@ -5488,18 +6268,12 @@ async function readComposioConnectionsBySlug() {
   return bySlug;
 }
 async function readComposioStatus() {
-  const cliVersion = (() => {
-    const command = resolveComposioCommand();
-    if (!command) return "";
-    const invocation = getSpawnInvocation(command, ["--version"]);
-    const probe = spawnSync4(invocation.command, invocation.args, {
-      encoding: "utf8",
-      windowsHide: true
-    });
-    return probe.status === 0 ? probe.stdout.trim() : "";
-  })();
+  const versionInvocation = buildComposioInvocation(["--version"]);
+  const probe = versionInvocation ? probeComposioInvocation(versionInvocation) : { available: false, cliVersion: "", output: "" };
+  const available = probe.available;
+  const cliVersion = probe.cliVersion;
   const userData = await readComposioUserData();
-  if (!resolveComposioCommand()) {
+  if (!available) {
     return {
       available: false,
       authenticated: false,
@@ -5609,11 +6383,10 @@ async function startComposioLink(slug) {
   };
 }
 async function startComposioLogin() {
-  const command = resolveComposioCommand();
-  if (!command) {
+  const invocation = resolveComposioInvocation(["login", "--no-browser", "-y"]);
+  if (!invocation) {
     throw new Error("Composio CLI is not installed");
   }
-  const invocation = getSpawnInvocation(command, ["login", "--no-browser", "-y"]);
   const proc = spawn4(invocation.command, invocation.args, {
     cwd: process.cwd(),
     env: process.env,
@@ -6470,6 +7243,63 @@ function normalizeBranchRefName(value) {
   if (trimmed.startsWith("refs/remotes/")) return trimmed.slice("refs/remotes/".length);
   return trimmed;
 }
+function toHeaderGitResetHistoryRef(branchName, commitSha) {
+  return `refs/codex/header-git-reset-history/${branchName}/${commitSha}`;
+}
+var HEADER_GIT_RESET_HISTORY_REF_LIMIT = 25;
+async function assertLocalGitBranch(repoRoot, branchName) {
+  await runCommandCapture2("git", ["show-ref", "--verify", `refs/heads/${branchName}`], { cwd: repoRoot });
+}
+async function checkoutGitBranchWithWorktreeRecovery(repoRoot, branchName) {
+  try {
+    await runCommand3("git", ["checkout", branchName], { cwd: repoRoot });
+  } catch (checkoutError) {
+    const blockingWorktreePath = extractBranchLockedWorktreePath(checkoutError, branchName);
+    if (!blockingWorktreePath) {
+      throw checkoutError;
+    }
+    await runCommand3("git", ["checkout", "--detach"], { cwd: blockingWorktreePath });
+    await runCommand3("git", ["checkout", branchName], { cwd: repoRoot });
+  }
+}
+async function pruneHeaderGitResetHistoryRefs(repoRoot, branchName) {
+  const resetHistoryRefPrefix = `refs/codex/header-git-reset-history/${branchName}/`;
+  const refsRaw = await runCommandCapture2(
+    "git",
+    ["for-each-ref", "--sort=-creatordate", "--format=%(refname)", resetHistoryRefPrefix],
+    { cwd: repoRoot }
+  ).catch(() => "");
+  const refs = refsRaw.split("\n").map((entry) => entry.trim()).filter(Boolean);
+  const staleRefs = refs.slice(HEADER_GIT_RESET_HISTORY_REF_LIMIT);
+  for (const refName of staleRefs) {
+    await runCommand3("git", ["update-ref", "-d", refName], { cwd: repoRoot });
+  }
+}
+async function readGitHeaderState(cwd) {
+  const gitRoot = await runCommandCapture2("git", ["rev-parse", "--show-toplevel"], { cwd });
+  const currentBranchRaw = await runCommandCapture2("git", ["branch", "--show-current"], { cwd: gitRoot });
+  const currentBranch = currentBranchRaw.trim() || null;
+  const headShaRaw = await runCommandCapture2("git", ["rev-parse", "--short=12", "HEAD"], { cwd: gitRoot });
+  const headCommitRaw = await runCommandCapture2("git", ["show", "-s", "--date=short", "--format=%cd%x09%s", "HEAD"], { cwd: gitRoot });
+  const [headDate = "", ...headSubjectParts] = headCommitRaw.split("	");
+  const statusRaw = await runCommandCapture2("git", ["status", "--porcelain"], { cwd: gitRoot });
+  return {
+    currentBranch,
+    headSha: headShaRaw.trim() || null,
+    headSubject: headSubjectParts.join("	").trim() || null,
+    headDate: headDate.trim() || null,
+    detached: !currentBranch,
+    dirty: statusRaw.trim().length > 0,
+    gitRoot
+  };
+}
+async function assertNoTrackedGitChanges(repoRoot) {
+  const statusRaw = await runCommandCapture2("git", ["status", "--porcelain"], { cwd: repoRoot });
+  const trackedChanges = statusRaw.split("\n").map((line) => line.trimEnd()).filter((line) => line && !line.startsWith("?? "));
+  if (trackedChanges.length > 0) {
+    throw new Error("Cannot switch branches or reset with tracked uncommitted changes. Commit, stash, or discard tracked changes first. Untracked files are allowed unless Git would overwrite them.");
+  }
+}
 function extractBranchLockedWorktreePath(error, branchName) {
   const message = getErrorMessage5(error, "");
   if (!message || !branchName) return "";
@@ -6478,6 +7308,35 @@ function extractBranchLockedWorktreePath(error, branchName) {
   const match = pattern.exec(message);
   return match?.[1]?.trim() ?? "";
 }
+function toPermanentWorktreeBranchNameDraft(worktreeName) {
+  const sanitized = worktreeName.trim().replace(/[^A-Za-z0-9._-]+/gu, "-").replace(/\.+/gu, ".").replace(/-+/gu, "-").replace(/^[.-]+|[.-]+$/gu, "");
+  return sanitized || "worktree";
+}
+async function isValidGitBranchName(gitRoot, branchName) {
+  try {
+    await runCommand3("git", ["check-ref-format", "--branch", branchName], { cwd: gitRoot });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function doesLocalGitBranchExist(gitRoot, branchName) {
+  try {
+    await runCommand3("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: gitRoot });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function allocatePermanentWorktreeBranchName(gitRoot, worktreeName) {
+  const base = toPermanentWorktreeBranchNameDraft(worktreeName);
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    const candidate = attempt === 0 ? base : `${base}-${attempt + 1}`;
+    if (!await isValidGitBranchName(gitRoot, candidate)) continue;
+    if (!await doesLocalGitBranchExist(gitRoot, candidate)) return candidate;
+  }
+  throw new Error("Failed to allocate a unique branch name for worktree");
+}
 function normalizeStringArray(value) {
   if (!Array.isArray(value)) return [];
   const normalized = [];
@@ -6498,9 +7357,133 @@ function normalizeStringRecord(value) {
   }
   return next;
 }
+function normalizeRemoteProjects(value) {
+  if (!Array.isArray(value)) return [];
+  const next = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value) {
+    const record = asRecord5(item);
+    if (!record) continue;
+    const id = typeof record.id === "string" ? record.id.trim() : "";
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    next.push({
+      id,
+      hostId: typeof record.hostId === "string" ? record.hostId.trim() : "",
+      remotePath: typeof record.remotePath === "string" ? record.remotePath.trim() : "",
+      label: typeof record.label === "string" ? record.label.trim() : ""
+    });
+  }
+  return next;
+}
 function getCodexAuthPath() {
   return join6(getCodexHomeDir3(), "auth.json");
 }
+var CODEX_CHATGPT_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var DEFAULT_CODEX_REFRESH_TOKEN_URL = "https://auth.openai.com/oauth/token";
+function decodeBase64UrlJson2(value) {
+  try {
+    const padded = `${value}${"=".repeat((4 - value.length % 4) % 4)}`;
+    const decoded = Buffer.from(padded.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    return asRecord5(parsed);
+  } catch {
+    return null;
+  }
+}
+function decodeJwtPayload(token) {
+  if (!token) return null;
+  const parts = token.split(".");
+  if (parts.length < 2) return null;
+  return decodeBase64UrlJson2(parts[1] ?? "");
+}
+function extractChatgptTokenMetadata(accessToken) {
+  const payload = decodeJwtPayload(accessToken);
+  const auth = asRecord5(payload?.["https://api.openai.com/auth"]);
+  return {
+    chatgptAccountId: readNonEmptyString(auth?.chatgpt_account_id) || null,
+    chatgptPlanType: readNonEmptyString(auth?.chatgpt_plan_type) || null
+  };
+}
+function readTokenErrorMessage(payload, fallback) {
+  const record = asRecord5(payload);
+  const message = readNonEmptyString(record?.message);
+  if (message) return message;
+  const error = record?.error;
+  if (typeof error === "string" && error.trim().length > 0) return error.trim();
+  const nestedError = asRecord5(error);
+  return readNonEmptyString(nestedError?.message) || readNonEmptyString(nestedError?.error_description) || readNonEmptyString(record?.error_description) || fallback;
+}
+function readTokenResponseString(payload, ...keys) {
+  if (!payload) return null;
+  for (const key of keys) {
+    const value = readNonEmptyString(payload[key]);
+    if (value) return value;
+  }
+  return null;
+}
+async function refreshChatgptAuthTokensForExternalAuth(params = {}) {
+  const authPath = getCodexAuthPath();
+  const raw = await readFile3(authPath, "utf8");
+  const auth = JSON.parse(raw);
+  const currentRefreshToken = auth.tokens?.refresh_token?.trim() ?? "";
+  if (!currentRefreshToken) {
+    throw new Error("No ChatGPT refresh token is available. Please sign in again.");
+  }
+  const refreshUrl = process.env.CODEX_REFRESH_TOKEN_URL_OVERRIDE?.trim() || DEFAULT_CODEX_REFRESH_TOKEN_URL;
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: currentRefreshToken,
+    client_id: CODEX_CHATGPT_CLIENT_ID
+  });
+  const response = await fetch(refreshUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: body.toString(),
+    signal: AbortSignal.timeout(25e3)
+  });
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = asRecord5(JSON.parse(text));
+  } catch {
+    payload = null;
+  }
+  if (!response.ok) {
+    throw new Error(readTokenErrorMessage(payload, `ChatGPT token refresh failed with HTTP ${String(response.status)}`));
+  }
+  const accessToken = readTokenResponseString(payload, "access_token", "accessToken");
+  if (!accessToken) {
+    throw new Error("ChatGPT token refresh response did not include an access token.");
+  }
+  const nextRefreshToken = readTokenResponseString(payload, "refresh_token", "refreshToken") ?? currentRefreshToken;
+  const nextIdToken = readTokenResponseString(payload, "id_token", "idToken") ?? auth.tokens?.id_token;
+  const metadata = extractChatgptTokenMetadata(accessToken);
+  const chatgptAccountId = metadata.chatgptAccountId || readTokenResponseString(payload, "chatgpt_account_id", "chatgptAccountId") || readNonEmptyString(params.previousAccountId) || readNonEmptyString(auth.tokens?.account_id);
+  if (!chatgptAccountId) {
+    throw new Error("ChatGPT token refresh response did not include account metadata.");
+  }
+  const nextAuth = {
+    ...auth,
+    auth_mode: auth.auth_mode || "chatgpt",
+    last_refresh: Date.now(),
+    tokens: {
+      ...auth.tokens,
+      access_token: accessToken,
+      refresh_token: nextRefreshToken,
+      account_id: chatgptAccountId,
+      ...nextIdToken ? { id_token: nextIdToken } : {}
+    }
+  };
+  await writeFile4(authPath, JSON.stringify(nextAuth, null, 2), { encoding: "utf8", mode: 384 });
+  return {
+    accessToken,
+    chatgptAccountId,
+    chatgptPlanType: metadata.chatgptPlanType
+  };
+}
 async function readCodexAuth() {
   try {
     const raw = await readFile3(getCodexAuthPath(), "utf8");
@@ -6512,6 +7495,37 @@ async function readCodexAuth() {
     return null;
   }
 }
+function hasUsableCodexAuthSync() {
+  try {
+    const raw = readFileSync2(getCodexAuthPath(), "utf8");
+    const auth = JSON.parse(raw);
+    return Boolean(auth.tokens?.access_token?.trim());
+  } catch {
+    return false;
+  }
+}
+function readFreeModeStateSync(statePath) {
+  try {
+    return JSON.parse(readFileSync2(statePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDefaultFreeModeStateForMissingAuthSync(statePath) {
+  const current = readFreeModeStateSync(statePath);
+  if (!shouldCreateDefaultFreeModeStateForMissingAuth(current, hasUsableCodexAuthSync())) {
+    return current;
+  }
+  const fallback = createDefaultOpenCodeZenFreeModeState();
+  mkdirSync(dirname2(statePath), { recursive: true });
+  writeFileSync2(statePath, JSON.stringify(fallback), { encoding: "utf8", mode: 384 });
+  return fallback;
+}
+function isLoopbackRemoteAddress(remoteAddress) {
+  if (!remoteAddress) return false;
+  const normalized = remoteAddress.startsWith("::ffff:") ? remoteAddress.slice("::ffff:".length) : remoteAddress;
+  return normalized === "127.0.0.1" || normalized === "::1";
+}
 function getCodexGlobalStatePath() {
   return join6(getCodexHomeDir3(), ".codex-global-state.json");
 }
@@ -6615,13 +7629,35 @@ async function listThreadHeartbeatAutomations() {
     if (!entry.isDirectory()) continue;
     const automation = await readAutomationRecordFromFile(join6(automationRoot, entry.name, "automation.toml"));
     if (!automation || automation.kind !== "heartbeat" || !automation.targetThreadId) continue;
-    next[automation.targetThreadId] = automation;
+    next[automation.targetThreadId] = [...next[automation.targetThreadId] ?? [], automation];
+  }
+  for (const automations of Object.values(next)) {
+    automations.sort((first, second) => {
+      const firstCreatedAt = first.createdAtMs ?? 0;
+      const secondCreatedAt = second.createdAtMs ?? 0;
+      if (firstCreatedAt !== secondCreatedAt) return firstCreatedAt - secondCreatedAt;
+      return first.id.localeCompare(second.id);
+    });
   }
   return next;
 }
-async function readThreadHeartbeatAutomation(threadId) {
+async function readThreadHeartbeatAutomations(threadId) {
   const all = await listThreadHeartbeatAutomations();
-  return all[threadId] ?? null;
+  return all[threadId] ?? [];
+}
+async function readThreadHeartbeatAutomation(threadId, automationId = "") {
+  const automations = await readThreadHeartbeatAutomations(threadId);
+  if (automationId) return automations.find((automation) => automation.id === automationId) ?? null;
+  return automations[0] ?? null;
+}
+function resolveUniqueAutomationId(existingIds, threadId, name) {
+  const baseId = slugifyAutomationId(threadId, name);
+  if (!existingIds.has(baseId)) return baseId;
+  for (let index = 2; index < 1e3; index += 1) {
+    const candidate = `${baseId}-${index}`;
+    if (!existingIds.has(candidate)) return candidate;
+  }
+  return `${baseId}-${randomBytes(4).toString("hex")}`;
 }
 async function writeThreadHeartbeatAutomation(input) {
   const threadId = input.threadId.trim();
@@ -6633,8 +7669,10 @@ async function writeThreadHeartbeatAutomation(input) {
   }
   const automationRoot = getCodexAutomationsDir();
   await mkdir4(automationRoot, { recursive: true });
-  const existing = await readThreadHeartbeatAutomation(threadId);
-  const id = existing?.id ?? slugifyAutomationId(threadId, name);
+  const existing = input.id ? await readThreadHeartbeatAutomation(threadId, input.id.trim()) : null;
+  const entries = await readdir2(automationRoot, { withFileTypes: true }).catch(() => []);
+  const existingIds = new Set(entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name));
+  const id = existing?.id ?? resolveUniqueAutomationId(existingIds, threadId, name);
   const automationDir = join6(automationRoot, id);
   const now = Date.now();
   const record = {
@@ -6659,10 +7697,18 @@ async function writeThreadHeartbeatAutomation(input) {
   }
   return record;
 }
-async function deleteThreadHeartbeatAutomation(threadId) {
-  const automation = await readThreadHeartbeatAutomation(threadId.trim());
-  if (!automation) return false;
-  await rm4(join6(getCodexAutomationsDir(), automation.id), { recursive: true, force: true });
+async function deleteThreadHeartbeatAutomation(threadId, automationId = "") {
+  const normalizedThreadId = threadId.trim();
+  const normalizedAutomationId = automationId.trim();
+  if (normalizedAutomationId) {
+    const automation = await readThreadHeartbeatAutomation(normalizedThreadId, normalizedAutomationId);
+    if (!automation) return false;
+    await rm4(join6(getCodexAutomationsDir(), automation.id), { recursive: true, force: true });
+    return true;
+  }
+  const automations = await readThreadHeartbeatAutomations(normalizedThreadId);
+  if (automations.length === 0) return false;
+  await Promise.all(automations.map((automation) => rm4(join6(getCodexAutomationsDir(), automation.id), { recursive: true, force: true })));
   return true;
 }
 var MAX_THREAD_TITLES = 500;
@@ -6840,6 +7886,7 @@ function normalizeThreadQueueState(value) {
   }
   return state;
 }
+var threadQueueMutationChain = Promise.resolve();
 async function readThreadQueueState() {
   const statePath = getCodexGlobalStatePath();
   try {
@@ -6850,7 +7897,7 @@ async function readThreadQueueState() {
     return {};
   }
 }
-async function writeThreadQueueState(nextState) {
+async function writeThreadQueueStateUnlocked(nextState) {
   const statePath = getCodexGlobalStatePath();
   let payload = {};
   try {
@@ -6867,6 +7914,34 @@ async function writeThreadQueueState(nextState) {
   }
   await writeFile4(statePath, JSON.stringify(payload), "utf8");
 }
+async function withThreadQueueStateUpdate(update) {
+  const run = threadQueueMutationChain.then(async () => {
+    const currentState = await readThreadQueueState();
+    const { nextState, result } = await update(currentState);
+    await writeThreadQueueStateUnlocked(nextState);
+    return result;
+  });
+  threadQueueMutationChain = run.catch(() => {
+  });
+  return run;
+}
+async function writeThreadQueueState(nextState) {
+  await withThreadQueueStateUpdate(() => ({
+    nextState: normalizeThreadQueueState(nextState),
+    result: void 0
+  }));
+}
+async function appendThreadQueuedMessage(threadId, message) {
+  const normalizedThreadId = threadId.trim();
+  if (!normalizedThreadId) throw new Error("threadId is required");
+  await withThreadQueueStateUpdate((state) => ({
+    nextState: {
+      ...state,
+      [normalizedThreadId]: [...state[normalizedThreadId] ?? [], message]
+    },
+    result: void 0
+  }));
+}
 function normalizeReasoningEffort(value) {
   const allowed = ["none", "minimal", "low", "medium", "high", "xhigh"];
   return typeof value === "string" && allowed.includes(value) ? value : "";
@@ -6899,6 +7974,25 @@ function buildTextWithAttachments(prompt, files) {
 ${prompt}
 `;
 }
+function escapeHeartbeatXmlText(value) {
+  return value.replace(/&/gu, "&amp;").replace(/</gu, "&lt;").replace(/>/gu, "&gt;");
+}
+function buildHeartbeatQueuedMessage(automation) {
+  return {
+    id: `automation-${automation.id}-${Date.now()}-${randomBytes(3).toString("hex")}`,
+    text: `<heartbeat>
+<automation_id>${escapeHeartbeatXmlText(automation.id)}</automation_id>
+<current_time_iso>${(/* @__PURE__ */ new Date()).toISOString()}</current_time_iso>
+<instructions>
+${escapeHeartbeatXmlText(automation.prompt)}
+</instructions>
+</heartbeat>`,
+    imageUrls: [],
+    skills: [],
+    fileAttachments: [],
+    collaborationMode: "default"
+  };
+}
 function fileNameFromPath(pathValue) {
   const normalized = pathValue.replace(/\\/g, "/");
   const segments = normalized.split("/").filter(Boolean);
@@ -7019,7 +8113,9 @@ async function readWorkspaceRootsState() {
   return {
     order: normalizeStringArray(payload["electron-saved-workspace-roots"]),
     labels: normalizeStringRecord(payload["electron-workspace-root-labels"]),
-    active: normalizeStringArray(payload["active-workspace-roots"])
+    active: normalizeStringArray(payload["active-workspace-roots"]),
+    projectOrder: normalizeStringArray(payload["project-order"]),
+    remoteProjects: normalizeRemoteProjects(payload["remote-projects"])
   };
 }
 async function writeWorkspaceRootsState(nextState) {
@@ -7034,8 +8130,58 @@ async function writeWorkspaceRootsState(nextState) {
   payload["electron-saved-workspace-roots"] = normalizeStringArray(nextState.order);
   payload["electron-workspace-root-labels"] = normalizeStringRecord(nextState.labels);
   payload["active-workspace-roots"] = normalizeStringArray(nextState.active);
+  payload["project-order"] = normalizeStringArray(nextState.projectOrder);
   await writeFile4(statePath, JSON.stringify(payload), "utf8");
 }
+var workspaceRootsMutation = Promise.resolve();
+function queueWorkspaceRootsMutation(mutation) {
+  const run = workspaceRootsMutation.catch(() => void 0).then(mutation);
+  workspaceRootsMutation = run.then(
+    () => void 0,
+    () => void 0
+  );
+  return run;
+}
+function prependUniqueString(value, items) {
+  return [value, ...items.filter((item) => item !== value)];
+}
+async function updateWorkspaceRootsState(updater) {
+  await queueWorkspaceRootsMutation(async () => {
+    const existingState = await readWorkspaceRootsState();
+    await writeWorkspaceRootsState(updater(existingState));
+  });
+}
+async function persistWorkspaceRoot(workspaceRoot, label = "") {
+  const normalizedRoot = workspaceRoot.trim();
+  if (!normalizedRoot) return;
+  await updateWorkspaceRootsState((existingState) => {
+    const nextLabels = { ...existingState.labels };
+    const trimmedLabel = label.trim();
+    if (trimmedLabel.length > 0) {
+      nextLabels[normalizedRoot] = trimmedLabel;
+    }
+    return {
+      order: prependUniqueString(normalizedRoot, existingState.order),
+      labels: nextLabels,
+      active: prependUniqueString(normalizedRoot, existingState.active),
+      projectOrder: prependUniqueString(normalizedRoot, existingState.projectOrder),
+      remoteProjects: existingState.remoteProjects
+    };
+  });
+}
+async function rollbackCreatedWorktree(gitRoot, worktreeCwd, cleanupDirectory, branchName) {
+  try {
+    await runCommand3("git", ["worktree", "remove", "--force", worktreeCwd], { cwd: gitRoot });
+  } catch {
+    await rm4(worktreeCwd, { recursive: true, force: true }).catch(() => void 0);
+  }
+  if (cleanupDirectory && cleanupDirectory !== worktreeCwd) {
+    await rm4(cleanupDirectory, { recursive: true, force: true }).catch(() => void 0);
+  }
+  if (branchName) {
+    await runCommand3("git", ["branch", "-D", branchName], { cwd: gitRoot }).catch(() => void 0);
+  }
+}
 function normalizeTelegramBridgeConfig(value) {
   const record = asRecord5(value);
   if (!record) return { botToken: "", chatIds: [], allowedUserIds: [] };
@@ -7091,7 +8237,7 @@ function rememberTelegramChatId(chatId) {
   });
   return telegramBridgeConfigMutation;
 }
-async function readJsonBody(req) {
+async function readJsonBody2(req) {
   const raw = await readRawBody(req);
   if (raw.length === 0) return null;
   const text = raw.toString("utf8").trim();
@@ -7309,6 +8455,7 @@ var AppServerProcess = class {
     this.lastThreadReadSnapshotByThreadId = /* @__PURE__ */ new Map();
     this.capturedItemsByThreadId = /* @__PURE__ */ new Map();
     this.liveStateCache = /* @__PURE__ */ new Map();
+    this.chatgptAuthRefreshPromise = null;
   }
   getCodexCommand() {
     const codexCommand = resolveCodexCommand();
@@ -7329,10 +8476,11 @@ var AppServerProcess = class {
     const serverPort = parseInt(process.env.CODEXUI_SERVER_PORT ?? "", 10) || void 0;
     const statePath = join6(getCodexHomeDir3(), FREE_MODE_STATE_FILE);
     try {
-      const raw = readFileSync2(statePath, "utf8");
-      const state = JSON.parse(raw);
-      args.push(...getFreeModeConfigArgs(state, serverPort));
-      extraEnv = getFreeModeEnvVars(state);
+      const state = ensureDefaultFreeModeStateForMissingAuthSync(statePath);
+      if (state) {
+        args.push(...getFreeModeConfigArgs(state, serverPort));
+        extraEnv = getFreeModeEnvVars(state);
+      }
     } catch {
     }
     return { args, env: extraEnv };
@@ -7571,7 +8719,46 @@ var AppServerProcess = class {
       }
     });
   }
+  async refreshChatgptAuthTokens(params) {
+    if (!this.chatgptAuthRefreshPromise) {
+      this.chatgptAuthRefreshPromise = refreshChatgptAuthTokensForExternalAuth(params).finally(() => {
+        this.chatgptAuthRefreshPromise = null;
+      });
+    }
+    return await this.chatgptAuthRefreshPromise;
+  }
+  async handleChatgptAuthTokensRefreshRequest(requestId, params) {
+    const requestParams = asRecord5(params);
+    const previousAccountId = readNonEmptyString(requestParams?.previousAccountId ?? requestParams?.previous_account_id);
+    try {
+      const result = await this.refreshChatgptAuthTokens({
+        reason: readNonEmptyString(requestParams?.reason) || void 0,
+        previousAccountId: previousAccountId || void 0
+      });
+      this.sendServerRequestReply(requestId, { result });
+      this.emitNotification({
+        method: "server/request/resolved",
+        params: {
+          id: requestId,
+          method: "account/chatgptAuthTokens/refresh",
+          mode: "automatic",
+          resolvedAtIso: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    } catch (error) {
+      this.sendServerRequestReply(requestId, {
+        error: {
+          code: -32001,
+          message: getErrorMessage5(error, "Failed to refresh ChatGPT auth tokens")
+        }
+      });
+    }
+  }
   handleServerRequest(requestId, method, params) {
+    if (method === "account/chatgptAuthTokens/refresh") {
+      void this.handleChatgptAuthTokensRefreshRequest(requestId, params);
+      return;
+    }
     const pendingRequest = {
       id: requestId,
       method,
@@ -7694,53 +8881,124 @@ var BackendQueueProcessor = class {
   constructor(appServer) {
     this.appServer = appServer;
     this.processingThreadIds = /* @__PURE__ */ new Set();
+    this.queueDrainTimersByThreadId = /* @__PURE__ */ new Map();
+    this.queueDrainDueAtByThreadId = /* @__PURE__ */ new Map();
     this.unsubscribe = appServer.onNotification((notification) => {
       if (!isTurnCompletedNotification(notification)) return;
       const threadId = extractThreadIdFromNotificationParams(notification.params);
       if (!threadId) return;
       void this.processThreadQueue(threadId);
     });
+    void this.scheduleAllQueuedThreads(1e3);
   }
   dispose() {
     this.unsubscribe();
+    for (const timer of this.queueDrainTimersByThreadId.values()) {
+      clearTimeout(timer);
+    }
+    this.queueDrainTimersByThreadId.clear();
+    this.queueDrainDueAtByThreadId.clear();
     this.processingThreadIds.clear();
   }
+  async scheduleAllQueuedThreads(delayMs = 0) {
+    try {
+      const state = await readThreadQueueState();
+      for (const threadId of Object.keys(state)) {
+        this.scheduleThreadQueueDrain(threadId, delayMs);
+      }
+    } catch {
+    }
+  }
+  scheduleThreadQueueDrain(threadId, delayMs = 5e3) {
+    if (!threadId) return;
+    const normalizedDelayMs = Math.max(0, delayMs);
+    const nextDueAt = Date.now() + normalizedDelayMs;
+    const existingDueAt = this.queueDrainDueAtByThreadId.get(threadId);
+    const existingTimer = this.queueDrainTimersByThreadId.get(threadId);
+    if (existingTimer) {
+      if (existingDueAt !== void 0 && existingDueAt <= nextDueAt) return;
+      clearTimeout(existingTimer);
+      this.queueDrainTimersByThreadId.delete(threadId);
+      this.queueDrainDueAtByThreadId.delete(threadId);
+    }
+    const timer = setTimeout(() => {
+      this.queueDrainTimersByThreadId.delete(threadId);
+      this.queueDrainDueAtByThreadId.delete(threadId);
+      void this.processThreadQueue(threadId);
+    }, normalizedDelayMs);
+    timer.unref?.();
+    this.queueDrainTimersByThreadId.set(threadId, timer);
+    this.queueDrainDueAtByThreadId.set(threadId, nextDueAt);
+  }
   async processThreadQueue(threadId) {
     if (this.processingThreadIds.has(threadId)) return;
     this.processingThreadIds.add(threadId);
     try {
+      const canStart = await this.canStartQueuedTurn(threadId);
+      if (!canStart) {
+        if (await this.hasQueuedTurns(threadId)) {
+          this.scheduleThreadQueueDrain(threadId);
+        }
+        return;
+      }
       const next = await this.popNextQueuedTurn(threadId);
       if (!next) return;
       try {
         await this.startQueuedTurn(next);
+        if (await this.hasQueuedTurns(threadId)) {
+          this.scheduleThreadQueueDrain(threadId);
+        }
       } catch {
         await this.restoreQueuedTurn(next);
+        this.scheduleThreadQueueDrain(threadId);
       }
     } catch {
+      this.scheduleThreadQueueDrain(threadId);
     } finally {
       this.processingThreadIds.delete(threadId);
     }
   }
-  async popNextQueuedTurn(threadId) {
+  async hasQueuedTurns(threadId) {
     const state = await readThreadQueueState();
     const queue = state[threadId];
-    if (!queue || queue.length === 0) return null;
-    const [message, ...rest] = queue;
-    const nextState = { ...state };
-    if (rest.length > 0) {
-      nextState[threadId] = rest;
-    } else {
-      delete nextState[threadId];
-    }
-    await writeThreadQueueState(nextState);
-    return { threadId, message };
+    return Array.isArray(queue) && queue.length > 0;
+  }
+  async canStartQueuedTurn(threadId) {
+    const response = asRecord5(await this.appServer.rpc("thread/read", { threadId, includeTurns: true }));
+    const thread = asRecord5(response?.thread);
+    if (!thread) return false;
+    const status = asRecord5(thread.status);
+    const statusType = readNonEmptyString(status?.type);
+    if (statusType === "inProgress" || statusType === "running" || statusType === "active") return false;
+    const turns = Array.isArray(thread.turns) ? thread.turns : [];
+    return !turns.some((turn) => readNonEmptyString(asRecord5(turn)?.status) === "inProgress");
+  }
+  async popNextQueuedTurn(threadId) {
+    return withThreadQueueStateUpdate((state) => {
+      const queue = state[threadId];
+      if (!queue || queue.length === 0) {
+        return { nextState: state, result: null };
+      }
+      const [message, ...rest] = queue;
+      const nextState = { ...state };
+      if (rest.length > 0) {
+        nextState[threadId] = rest;
+      } else {
+        delete nextState[threadId];
+      }
+      return { nextState, result: { threadId, message } };
+    });
   }
   async restoreQueuedTurn(turn) {
-    const state = await readThreadQueueState();
-    const queue = state[turn.threadId] ?? [];
-    await writeThreadQueueState({
-      ...state,
-      [turn.threadId]: [turn.message, ...queue]
+    await withThreadQueueStateUpdate((state) => {
+      const queue = state[turn.threadId] ?? [];
+      return {
+        nextState: {
+          ...state,
+          [turn.threadId]: [turn.message, ...queue]
+        },
+        result: void 0
+      };
     });
   }
   async resolveCollaborationModeSettings(mode) {
@@ -8091,6 +9349,10 @@ function createCodexBridgeMiddleware() {
       }
       const url = new URL(req.url, "http://localhost");
       if (url.pathname === "/codex-api/zen-proxy/v1/responses" && req.method === "POST") {
+        if (!isLoopbackRemoteAddress(req.socket.remoteAddress)) {
+          setJson4(res, 403, { error: "Zen proxy is only available from localhost" });
+          return;
+        }
         const statePath = join6(getCodexHomeDir3(), FREE_MODE_STATE_FILE);
         let bearerToken = "";
         let wireApi = "chat";
@@ -8108,9 +9370,9 @@ function createCodexBridgeMiddleware() {
         let bearerToken = "";
         let wireApi = "responses";
         try {
-          const state = JSON.parse(readFileSync2(statePath, "utf8"));
-          bearerToken = state.apiKey ?? "";
-          wireApi = state.wireApi === "chat" ? "chat" : "responses";
+          const state = ensureDefaultFreeModeStateForMissingAuthSync(statePath);
+          bearerToken = state?.apiKey ?? "";
+          wireApi = state?.wireApi === "chat" ? "chat" : "responses";
         } catch {
         }
         handleOpenRouterProxyRequest(req, res, bearerToken, wireApi);
@@ -8133,17 +9395,13 @@ function createCodexBridgeMiddleware() {
       }
       if (url.pathname.startsWith("/codex-api/free-mode")) {
         let readFreeModeState2 = function() {
-          try {
-            return JSON.parse(readFileSync2(statePath, "utf8"));
-          } catch {
-            return { enabled: false, apiKey: null, model: FREE_MODE_DEFAULT_MODEL };
-          }
+          return ensureDefaultFreeModeStateForMissingAuthSync(statePath) ?? { enabled: false, apiKey: null, model: FREE_MODE_DEFAULT_MODEL };
         };
         var readFreeModeState = readFreeModeState2;
         const statePath = join6(getCodexHomeDir3(), FREE_MODE_STATE_FILE);
         if (req.method === "POST" && url.pathname === "/codex-api/free-mode") {
           try {
-            const body = await readJsonBody(req);
+            const body = await readJsonBody2(req);
             const enable = Boolean(body?.enable);
             if (enable) {
               const apiKey = getRandomFreeKey();
@@ -8199,12 +9457,12 @@ function createCodexBridgeMiddleware() {
         if (req.method === "GET" && url.pathname === "/codex-api/free-mode/status") {
           try {
             const state = readFreeModeState2();
-            const freeModels = await getFreeModels();
             const maskedKey = state.apiKey && state.customKey ? state.apiKey.substring(0, 12) + "..." + state.apiKey.substring(state.apiKey.length - 4) : null;
+            refreshFreeModelsInBackground();
             setJson4(res, 200, {
               enabled: state.enabled,
               keyCount: getFreeKeyCount(),
-              models: freeModels,
+              models: getCachedFreeModels(),
               currentModel: state.enabled ? state.model : null,
               customKey: Boolean(state.customKey),
               maskedKey,
@@ -8236,7 +9494,7 @@ function createCodexBridgeMiddleware() {
         }
         if (req.method === "POST" && url.pathname === "/codex-api/free-mode/custom-key") {
           try {
-            const body = await readJsonBody(req);
+            const body = await readJsonBody2(req);
             const key = typeof body?.key === "string" ? body.key.trim() : "";
             const current = readFreeModeState2();
             if (key.length > 0) {
@@ -8271,7 +9529,7 @@ function createCodexBridgeMiddleware() {
         }
         if (req.method === "POST" && url.pathname === "/codex-api/free-mode/custom-provider") {
           try {
-            const body = await readJsonBody(req);
+            const body = await readJsonBody2(req);
             const baseUrl = typeof body?.baseUrl === "string" ? body.baseUrl.trim() : "";
             const apiKey = typeof body?.apiKey === "string" ? body.apiKey.trim() : "";
             const wireApi = body?.wireApi === "chat" ? "chat" : "responses";
@@ -8314,10 +9572,10 @@ function createCodexBridgeMiddleware() {
       if (await handleAccountRoutes(req, res, url, { appServer })) {
         return;
       }
-      if (await handleSkillsRoutes(req, res, url, { appServer, readJsonBody })) {
+      if (await handleSkillsRoutes(req, res, url, { appServer, readJsonBody: readJsonBody2 })) {
         return;
       }
-      if (await handleReviewRoutes(req, res, url, { readJsonBody })) {
+      if (await handleReviewRoutes(req, res, url, { readJsonBody: readJsonBody2 })) {
         return;
       }
       if (req.method === "GET" && url.pathname === "/codex-api/thread-terminal/status") {
@@ -8343,7 +9601,7 @@ function createCodexBridgeMiddleware() {
           setJson4(res, 503, { error: availability.reason || "Integrated terminal is unavailable on this host" });
           return;
         }
-        const body = asRecord5(await readJsonBody(req));
+        const body = asRecord5(await readJsonBody2(req));
         const threadId = readNonEmptyString(body?.threadId);
         const cwd = readNonEmptyString(body?.cwd);
         if (!threadId || !cwd) {
@@ -8367,7 +9625,7 @@ function createCodexBridgeMiddleware() {
           setJson4(res, 503, { error: availability.reason || "Integrated terminal is unavailable on this host" });
           return;
         }
-        const body = asRecord5(await readJsonBody(req));
+        const body = asRecord5(await readJsonBody2(req));
         const sessionId = readNonEmptyString(body?.sessionId);
         const data = typeof body?.data === "string" ? body.data : "";
         if (!sessionId) {
@@ -8384,7 +9642,7 @@ function createCodexBridgeMiddleware() {
           setJson4(res, 503, { error: availability.reason || "Integrated terminal is unavailable on this host" });
           return;
         }
-        const body = asRecord5(await readJsonBody(req));
+        const body = asRecord5(await readJsonBody2(req));
         const sessionId = readNonEmptyString(body?.sessionId);
         if (!sessionId) {
           setJson4(res, 400, { error: "Missing sessionId" });
@@ -8400,7 +9658,7 @@ function createCodexBridgeMiddleware() {
           setJson4(res, 503, { error: availability.reason || "Integrated terminal is unavailable on this host" });
           return;
         }
-        const body = asRecord5(await readJsonBody(req));
+        const body = asRecord5(await readJsonBody2(req));
         const sessionId = readNonEmptyString(body?.sessionId);
         if (!sessionId) {
           setJson4(res, 400, { error: "Missing sessionId" });
@@ -8424,7 +9682,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/rpc") {
-        const payload = await readJsonBody(req);
+        const payload = await readJsonBody2(req);
         const body = asRecord5(payload);
         if (payload !== null && payload !== void 0) {
           requestBodyBytes = Buffer.byteLength(JSON.stringify(payload), "utf8");
@@ -8434,9 +9692,10 @@ function createCodexBridgeMiddleware() {
           setJson4(res, 400, { error: "Invalid body: expected { method, params? }" });
           return;
         }
-        const rpcResult = await appServer.rpc(body.method, body.params ?? null);
+        const rpcResult = await callRpcWithArchiveRecovery(appServer, body.method, body.params ?? null);
         const trimmedResult = trimThreadTurnsInRpcResult(body.method, rpcResult);
-        const result = await sanitizeThreadTurnsInlinePayloads(body.method, trimmedResult);
+        const sanitizedResult = await sanitizeThreadTurnsInlinePayloads(body.method, trimmedResult);
+        const result = THREAD_METHODS_WITH_TURNS.has(body.method) ? await mergeSessionSkillInputsIntoThreadResult(sanitizedResult) : sanitizedResult;
         if (THREAD_METHODS_WITH_TURNS.has(body.method)) {
           const rpcRecord = asRecord5(result);
           const rpcThread = asRecord5(rpcRecord?.thread);
@@ -8572,7 +9831,7 @@ function createCodexBridgeMiddleware() {
       }
       if (req.method === "POST" && url.pathname === "/codex-api/thread/rollback-files") {
         try {
-          const body = asRecord5(await readJsonBody(req));
+          const body = asRecord5(await readJsonBody2(req));
           const threadId = readNonEmptyString(body?.threadId);
           const turnId = readNonEmptyString(body?.turnId);
           const cwd = readNonEmptyString(body?.cwd);
@@ -8668,7 +9927,7 @@ function createCodexBridgeMiddleware() {
       }
       if (req.method === "POST" && url.pathname === "/codex-api/composio/link") {
         try {
-          const payload = asRecord5(await readJsonBody(req));
+          const payload = asRecord5(await readJsonBody2(req));
           const slug = readNonEmptyString(payload?.slug);
           setJson4(res, 200, await startComposioLink(slug));
         } catch (error) {
@@ -8710,7 +9969,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/server-requests/respond") {
-        const payload = await readJsonBody(req);
+        const payload = await readJsonBody2(req);
         await appServer.respondToServerRequest(payload);
         setJson4(res, 200, { ok: true });
         return;
@@ -8731,8 +9990,8 @@ function createCodexBridgeMiddleware() {
       }
       if (req.method === "GET" && url.pathname === "/codex-api/provider-models") {
         try {
-          const fmState = JSON.parse(readFileSync2(join6(getCodexHomeDir3(), FREE_MODE_STATE_FILE), "utf8"));
-          if (fmState.enabled) {
+          const fmState = ensureDefaultFreeModeStateForMissingAuthSync(join6(getCodexHomeDir3(), FREE_MODE_STATE_FILE));
+          if (fmState?.enabled) {
             if (fmState.provider === "opencode-zen") {
               try {
                 const modelsUrl = "https://opencode.ai/zen/v1/models";
@@ -8800,7 +10059,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/worktree/create") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const rawSourceCwd = typeof payload?.sourceCwd === "string" ? payload.sourceCwd.trim() : "";
         const baseBranch = typeof payload?.baseBranch === "string" ? payload.baseBranch.trim() : "";
         if (!rawSourceCwd) {
@@ -8858,6 +10117,12 @@ function createCodexBridgeMiddleware() {
             await ensureRepoHasInitialCommit(gitRoot);
             await runCommand3("git", ["worktree", "add", "--detach", worktreeCwd, startPoint], { cwd: gitRoot });
           }
+          try {
+            await persistWorkspaceRoot(worktreeCwd);
+          } catch (error) {
+            await rollbackCreatedWorktree(gitRoot, worktreeCwd, worktreeParent);
+            throw error;
+          }
           setJson4(res, 200, {
             data: {
               cwd: worktreeCwd,
@@ -8870,6 +10135,75 @@ function createCodexBridgeMiddleware() {
         }
         return;
       }
+      if (req.method === "POST" && url.pathname === "/codex-api/worktree/create-permanent") {
+        const payload = asRecord5(await readJsonBody2(req));
+        const rawSourceCwd = typeof payload?.sourceCwd === "string" ? payload.sourceCwd.trim() : "";
+        const rawWorktreeName = typeof payload?.worktreeName === "string" ? payload.worktreeName.trim() : "";
+        if (!rawSourceCwd) {
+          setJson4(res, 400, { error: "Missing sourceCwd" });
+          return;
+        }
+        if (!rawWorktreeName) {
+          setJson4(res, 400, { error: "Missing worktreeName" });
+          return;
+        }
+        if (rawWorktreeName.includes("/") || rawWorktreeName.includes("\\") || rawWorktreeName === "." || rawWorktreeName === "..") {
+          setJson4(res, 400, { error: "Worktree name must be a single folder name" });
+          return;
+        }
+        const sourceCwd = isAbsolute2(rawSourceCwd) ? rawSourceCwd : resolve2(rawSourceCwd);
+        try {
+          const sourceInfo = await stat4(sourceCwd);
+          if (!sourceInfo.isDirectory()) {
+            setJson4(res, 400, { error: "sourceCwd is not a directory" });
+            return;
+          }
+        } catch {
+          setJson4(res, 404, { error: "sourceCwd does not exist" });
+          return;
+        }
+        try {
+          let gitRoot = "";
+          try {
+            gitRoot = await runCommandCapture2("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
+          } catch (error) {
+            if (!isNotGitRepositoryError2(error)) throw error;
+            await runCommand3("git", ["init"], { cwd: sourceCwd });
+            gitRoot = await runCommandCapture2("git", ["rev-parse", "--show-toplevel"], { cwd: sourceCwd });
+          }
+          const worktreeCwd = join6(dirname2(gitRoot), rawWorktreeName);
+          try {
+            await stat4(worktreeCwd);
+            setJson4(res, 409, { error: "Worktree folder already exists" });
+            return;
+          } catch {
+          }
+          const branchName = await allocatePermanentWorktreeBranchName(gitRoot, rawWorktreeName);
+          try {
+            await runCommand3("git", ["worktree", "add", "-b", branchName, worktreeCwd, "HEAD"], { cwd: gitRoot });
+          } catch (error) {
+            if (!isMissingHeadError2(error)) throw error;
+            await ensureRepoHasInitialCommit(gitRoot);
+            await runCommand3("git", ["worktree", "add", "-b", branchName, worktreeCwd, "HEAD"], { cwd: gitRoot });
+          }
+          try {
+            await persistWorkspaceRoot(worktreeCwd);
+          } catch (error) {
+            await rollbackCreatedWorktree(gitRoot, worktreeCwd, void 0, branchName);
+            throw error;
+          }
+          setJson4(res, 200, {
+            data: {
+              cwd: worktreeCwd,
+              branch: branchName,
+              gitRoot
+            }
+          });
+        } catch (error) {
+          setJson4(res, 500, { error: getErrorMessage5(error, "Failed to create worktree") });
+        }
+        return;
+      }
       if (req.method === "GET" && url.pathname === "/codex-api/worktree/branches") {
         const rawSourceCwd = (url.searchParams.get("sourceCwd") ?? "").trim();
         if (!rawSourceCwd) {
@@ -8956,11 +10290,11 @@ function createCodexBridgeMiddleware() {
             });
             return;
           }
-          const currentBranchRaw = await runCommandCapture2("git", ["branch", "--show-current"], { cwd: gitRoot });
-          const currentBranch = currentBranchRaw.trim() || null;
+          const state = await readGitHeaderState(gitRoot);
+          const currentBranch = state.currentBranch;
           const output = await runCommandCapture2(
             "git",
-            ["for-each-ref", "--format=%(committerdate:unix)	%(refname)", "refs/heads", "refs/remotes"],
+            ["for-each-ref", "--format=%(committerdate:unix)	%(refname)	%(objectname)", "refs/heads", "refs/remotes"],
             { cwd: gitRoot }
           );
           const branchActivityByName = /* @__PURE__ */ new Map();
@@ -8970,23 +10304,29 @@ function createCodexBridgeMiddleware() {
             if (!normalized || normalized === "origin/HEAD") continue;
             const parsedTimestamp = Number.parseInt(rawTimestamp.trim(), 10);
             const timestamp = Number.isFinite(parsedTimestamp) ? parsedTimestamp : 0;
-            const current = branchActivityByName.get(normalized) ?? Number.MIN_SAFE_INTEGER;
-            if (timestamp > current) {
-              branchActivityByName.set(normalized, timestamp);
+            const isRemote = rawRefName.trim().startsWith("refs/remotes/");
+            const current = branchActivityByName.get(normalized);
+            if (!current || timestamp > current.timestamp) {
+              branchActivityByName.set(normalized, { timestamp, isRemote });
             }
           }
           if (currentBranch && !branchActivityByName.has(currentBranch)) {
-            branchActivityByName.set(currentBranch, Number.MAX_SAFE_INTEGER);
+            branchActivityByName.set(currentBranch, { timestamp: Number.MAX_SAFE_INTEGER, isRemote: false });
           }
-          const options = Array.from(branchActivityByName.entries()).map(([value]) => ({ value, label: value })).sort((a, b) => {
-            const aActivity = branchActivityByName.get(a.value) ?? 0;
-            const bActivity = branchActivityByName.get(b.value) ?? 0;
+          const options = Array.from(branchActivityByName.entries()).map(([value, metadata]) => ({
+            value,
+            label: value,
+            isCurrent: value === currentBranch,
+            isRemote: metadata.isRemote
+          })).sort((a, b) => {
+            const aActivity = branchActivityByName.get(a.value)?.timestamp ?? 0;
+            const bActivity = branchActivityByName.get(b.value)?.timestamp ?? 0;
             if (bActivity !== aActivity) return bActivity - aActivity;
             return a.value.localeCompare(b.value);
           });
           setJson4(res, 200, {
             data: {
-              currentBranch,
+              ...state,
               options
             }
           });
@@ -8995,8 +10335,47 @@ function createCodexBridgeMiddleware() {
         }
         return;
       }
+      if (req.method === "GET" && url.pathname === "/codex-api/git/repository-status") {
+        const rawCwd = (url.searchParams.get("cwd") ?? "").trim();
+        if (!rawCwd) {
+          setJson4(res, 400, { error: "Missing cwd" });
+          return;
+        }
+        const cwd = isAbsolute2(rawCwd) ? rawCwd : resolve2(rawCwd);
+        try {
+          const cwdInfo = await stat4(cwd);
+          if (!cwdInfo.isDirectory()) {
+            setJson4(res, 400, { error: "cwd is not a directory" });
+            return;
+          }
+        } catch {
+          setJson4(res, 404, { error: "cwd does not exist" });
+          return;
+        }
+        try {
+          const gitRoot = await runCommandCapture2("git", ["rev-parse", "--show-toplevel"], { cwd });
+          setJson4(res, 200, {
+            data: {
+              isGitRepo: true,
+              gitRoot
+            }
+          });
+        } catch (error) {
+          if (!isNotGitRepositoryError2(error)) {
+            setJson4(res, 500, { error: getErrorMessage5(error, "Failed to read Git repository status") });
+            return;
+          }
+          setJson4(res, 200, {
+            data: {
+              isGitRepo: false,
+              gitRoot: ""
+            }
+          });
+        }
+        return;
+      }
       if (req.method === "POST" && url.pathname === "/codex-api/git/checkout") {
-        const payload = await readJsonBody(req);
+        const payload = await readJsonBody2(req);
         const record = asRecord5(payload);
         if (!record) {
           setJson4(res, 400, { error: "Invalid body: expected object" });
@@ -9025,52 +10404,127 @@ function createCodexBridgeMiddleware() {
         }
         try {
           const gitRoot = await runCommandCapture2("git", ["rev-parse", "--show-toplevel"], { cwd });
-          try {
-            await runCommand3("git", ["checkout", targetBranch], { cwd: gitRoot });
-          } catch (checkoutError) {
-            const blockingWorktreePath = extractBranchLockedWorktreePath(checkoutError, targetBranch);
-            if (!blockingWorktreePath) {
-              throw checkoutError;
-            }
-            await runCommand3("git", ["checkout", "--detach"], { cwd: blockingWorktreePath });
-            await runCommand3("git", ["checkout", targetBranch], { cwd: gitRoot });
-          }
-          const currentBranch = (await runCommandCapture2("git", ["branch", "--show-current"], { cwd: gitRoot })).trim() || null;
-          setJson4(res, 200, { data: { currentBranch } });
+          await assertNoTrackedGitChanges(gitRoot);
+          await checkoutGitBranchWithWorktreeRecovery(gitRoot, targetBranch);
+          setJson4(res, 200, { data: await readGitHeaderState(gitRoot) });
         } catch (error) {
           setJson4(res, 500, { error: getErrorMessage5(error, "Failed to switch branch") });
         }
         return;
       }
+      if (req.method === "GET" && url.pathname === "/codex-api/git/branch-commits") {
+        const rawCwd = (url.searchParams.get("cwd") ?? "").trim();
+        const branch = (url.searchParams.get("branch") ?? "").trim();
+        if (!rawCwd) {
+          setJson4(res, 400, { error: "Missing cwd" });
+          return;
+        }
+        if (!branch) {
+          setJson4(res, 400, { error: "Missing branch" });
+          return;
+        }
+        const cwd = isAbsolute2(rawCwd) ? rawCwd : resolve2(rawCwd);
+        try {
+          const gitRoot = await runCommandCapture2("git", ["rev-parse", "--show-toplevel"], { cwd });
+          await runCommandCapture2("git", ["rev-parse", "--verify", `${branch}^{commit}`], { cwd: gitRoot });
+          const resetHistoryRefPrefix = `refs/codex/header-git-reset-history/${branch}/`;
+          const resetHistoryRefsRaw = await runCommandCapture2(
+            "git",
+            ["for-each-ref", "--sort=-creatordate", "--format=%(refname)", resetHistoryRefPrefix],
+            { cwd: gitRoot }
+          ).catch(() => "");
+          const resetHistoryRefs = resetHistoryRefsRaw.split("\n").map((entry) => entry.trim()).filter(Boolean).slice(0, HEADER_GIT_RESET_HISTORY_REF_LIMIT);
+          const output = await runCommandCapture2(
+            "git",
+            ["log", "-n", "12", "--date=short", "--format=%H%x09%h%x09%cd%x09%s", branch, ...resetHistoryRefs],
+            { cwd: gitRoot }
+          );
+          const commits = output.split("\n").flatMap((line) => {
+            const [sha = "", shortSha = "", date = "", ...subjectParts] = line.split("	");
+            const subject = subjectParts.join("	").trim();
+            return sha.trim() && shortSha.trim() ? [{ sha: sha.trim(), shortSha: shortSha.trim(), date: date.trim(), subject: subject || shortSha.trim() }] : [];
+          });
+          setJson4(res, 200, { data: commits });
+        } catch (error) {
+          setJson4(res, 500, { error: getErrorMessage5(error, "Failed to load branch commits") });
+        }
+        return;
+      }
+      if (req.method === "POST" && url.pathname === "/codex-api/git/reset-to-commit") {
+        const payload = await readJsonBody2(req);
+        const record = asRecord5(payload);
+        if (!record) {
+          setJson4(res, 400, { error: "Invalid body: expected object" });
+          return;
+        }
+        const rawCwd = readNonEmptyString(record.cwd);
+        const branch = readNonEmptyString(record.branch);
+        const sha = readNonEmptyString(record.sha);
+        if (!rawCwd) {
+          setJson4(res, 400, { error: "Missing cwd" });
+          return;
+        }
+        if (!branch) {
+          setJson4(res, 400, { error: "Missing branch" });
+          return;
+        }
+        if (!sha) {
+          setJson4(res, 400, { error: "Missing commit" });
+          return;
+        }
+        const cwd = isAbsolute2(rawCwd) ? rawCwd : resolve2(rawCwd);
+        try {
+          const gitRoot = await runCommandCapture2("git", ["rev-parse", "--show-toplevel"], { cwd });
+          await assertNoTrackedGitChanges(gitRoot);
+          await assertLocalGitBranch(gitRoot, branch);
+          const currentBranch = (await runCommandCapture2("git", ["branch", "--show-current"], { cwd: gitRoot })).trim();
+          if (currentBranch && currentBranch !== branch) {
+            await checkoutGitBranchWithWorktreeRecovery(gitRoot, branch);
+          } else if (!currentBranch) {
+            await checkoutGitBranchWithWorktreeRecovery(gitRoot, branch);
+          }
+          const previousTip = await runCommandCapture2("git", ["rev-parse", "HEAD"], { cwd: gitRoot });
+          const targetSha = await runCommandCapture2("git", ["rev-parse", "--verify", `${sha}^{commit}`], { cwd: gitRoot });
+          await runCommand3("git", ["update-ref", toHeaderGitResetHistoryRef(branch, previousTip.trim()), previousTip.trim()], { cwd: gitRoot });
+          await pruneHeaderGitResetHistoryRefs(gitRoot, branch);
+          await runCommand3("git", ["reset", "--hard", targetSha.trim()], { cwd: gitRoot });
+          setJson4(res, 200, { data: await readGitHeaderState(gitRoot) });
+        } catch (error) {
+          setJson4(res, 500, { error: getErrorMessage5(error, "Failed to reset branch to commit") });
+        }
+        return;
+      }
       if (req.method === "PUT" && url.pathname === "/codex-api/workspace-roots-state") {
-        const payload = await readJsonBody(req);
+        const payload = await readJsonBody2(req);
         const record = asRecord5(payload);
         if (!record) {
           setJson4(res, 400, { error: "Invalid body: expected object" });
           return;
         }
-        const nextState = {
+        await updateWorkspaceRootsState((existingState) => ({
           order: normalizeStringArray(record.order),
           labels: normalizeStringRecord(record.labels),
-          active: normalizeStringArray(record.active)
-        };
-        await writeWorkspaceRootsState(nextState);
+          active: normalizeStringArray(record.active),
+          projectOrder: Array.isArray(record.projectOrder) ? normalizeStringArray(record.projectOrder) : existingState.projectOrder,
+          remoteProjects: existingState.remoteProjects
+        }));
         setJson4(res, 200, { ok: true });
         return;
       }
       if (req.method === "PUT" && url.pathname === "/codex-api/thread-queue-state") {
-        const payload = await readJsonBody(req);
+        const payload = await readJsonBody2(req);
         const record = asRecord5(payload);
         if (!record) {
           setJson4(res, 400, { error: "Invalid body: expected object" });
           return;
         }
         await writeThreadQueueState(normalizeThreadQueueState(record));
+        void backendQueueProcessor.scheduleAllQueuedThreads();
         setJson4(res, 200, { ok: true });
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/project-root") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const rawPath = typeof payload?.path === "string" ? payload.path.trim() : "";
         const createIfMissing = payload?.createIfMissing === true;
         const label = typeof payload?.label === "string" ? payload.label : "";
@@ -9095,23 +10549,12 @@ function createCodexBridgeMiddleware() {
           setJson4(res, 404, { error: "Directory does not exist" });
           return;
         }
-        const existingState = await readWorkspaceRootsState();
-        const nextOrder = [normalizedPath, ...existingState.order.filter((item) => item !== normalizedPath)];
-        const nextActive = [normalizedPath, ...existingState.active.filter((item) => item !== normalizedPath)];
-        const nextLabels = { ...existingState.labels };
-        if (label.trim().length > 0) {
-          nextLabels[normalizedPath] = label.trim();
-        }
-        await writeWorkspaceRootsState({
-          order: nextOrder,
-          labels: nextLabels,
-          active: nextActive
-        });
+        await persistWorkspaceRoot(normalizedPath, label);
         setJson4(res, 200, { data: { path: normalizedPath } });
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/local-directory") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const rawPath = typeof payload?.path === "string" ? payload.path.trim() : "";
         if (!rawPath) {
           setJson4(res, 400, { error: "Missing path" });
@@ -9131,7 +10574,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/projectless-thread-cwd") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const prompt = typeof payload?.prompt === "string" ? payload.prompt : null;
         try {
           const directory = await createProjectlessThreadDirectory(prompt);
@@ -9175,7 +10618,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/composer-file-search") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const rawCwd = typeof payload?.cwd === "string" ? payload.cwd.trim() : "";
         const query = typeof payload?.query === "string" ? payload.query.trim() : "";
         const limitRaw = typeof payload?.limit === "number" ? payload.limit : 20;
@@ -9209,7 +10652,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/prompts") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const name = typeof payload?.name === "string" ? payload.name.trim() : "";
         const content = typeof payload?.content === "string" ? payload.content : "";
         if (!name || !content.trim()) {
@@ -9260,16 +10703,17 @@ function createCodexBridgeMiddleware() {
       }
       if (req.method === "GET" && url.pathname === "/codex-api/thread-automation") {
         const threadId = url.searchParams.get("threadId")?.trim() ?? "";
+        const automationId = url.searchParams.get("automationId")?.trim() ?? "";
         if (!threadId) {
           setJson4(res, 400, { error: "Missing threadId" });
           return;
         }
-        const automation = await readThreadHeartbeatAutomation(threadId);
+        const automation = automationId ? await readThreadHeartbeatAutomation(threadId, automationId) : await readThreadHeartbeatAutomations(threadId);
         setJson4(res, 200, { data: automation });
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/thread-search") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const query = typeof payload?.query === "string" ? payload.query.trim() : "";
         const limitRaw = typeof payload?.limit === "number" ? payload.limit : 200;
         const limit = Math.max(1, Math.min(1e3, Math.floor(limitRaw)));
@@ -9283,7 +10727,7 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "PUT" && url.pathname === "/codex-api/thread-titles") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const id = typeof payload?.id === "string" ? payload.id : "";
         const title = typeof payload?.title === "string" ? payload.title : "";
         if (!id) {
@@ -9297,22 +10741,23 @@ function createCodexBridgeMiddleware() {
         return;
       }
       if (req.method === "PUT" && url.pathname === "/codex-api/thread-pins") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const threadIds = normalizePinnedThreadIds(payload?.threadIds);
         await writePinnedThreadIds(threadIds);
         setJson4(res, 200, { ok: true });
         return;
       }
       if (req.method === "PUT" && url.pathname === "/codex-api/preferences/first-launch-plugins-card") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const dismissed = payload?.dismissed === true;
         await writeFirstLaunchPluginsCardDismissed(dismissed);
         setJson4(res, 200, { ok: true });
         return;
       }
       if (req.method === "PUT" && url.pathname === "/codex-api/thread-automation") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const threadId = typeof payload?.threadId === "string" ? payload.threadId.trim() : "";
+        const id = typeof payload?.id === "string" ? payload.id.trim() : "";
         const name = typeof payload?.name === "string" ? payload.name.trim() : "";
         const prompt = typeof payload?.prompt === "string" ? payload.prompt.trim() : "";
         const rrule = typeof payload?.rrule === "string" ? payload.rrule.trim() : "";
@@ -9321,22 +10766,41 @@ function createCodexBridgeMiddleware() {
           setJson4(res, 400, { error: "threadId, name, prompt, and rrule are required" });
           return;
         }
-        const automation = await writeThreadHeartbeatAutomation({ threadId, name, prompt, rrule, status });
+        const automation = await writeThreadHeartbeatAutomation({ threadId, id, name, prompt, rrule, status });
         setJson4(res, 200, { data: automation });
         return;
       }
+      if (req.method === "POST" && url.pathname === "/codex-api/thread-automation/run") {
+        const payload = asRecord5(await readJsonBody2(req));
+        const threadId = typeof payload?.threadId === "string" ? payload.threadId.trim() : "";
+        const automationId = typeof payload?.automationId === "string" ? payload.automationId.trim() : "";
+        if (!threadId || !automationId) {
+          setJson4(res, 400, { error: "threadId and automationId are required" });
+          return;
+        }
+        const automation = await readThreadHeartbeatAutomation(threadId, automationId);
+        if (!automation) {
+          setJson4(res, 404, { error: "Automation not found for thread" });
+          return;
+        }
+        await appendThreadQueuedMessage(threadId, buildHeartbeatQueuedMessage(automation));
+        backendQueueProcessor.scheduleThreadQueueDrain(threadId, 0);
+        setJson4(res, 200, { data: { queued: true } });
+        return;
+      }
       if (req.method === "DELETE" && url.pathname === "/codex-api/thread-automation") {
         const threadId = url.searchParams.get("threadId")?.trim() ?? "";
+        const automationId = url.searchParams.get("automationId")?.trim() ?? "";
         if (!threadId) {
           setJson4(res, 400, { error: "Missing threadId" });
           return;
         }
-        const removed = await deleteThreadHeartbeatAutomation(threadId);
+        const removed = await deleteThreadHeartbeatAutomation(threadId, automationId);
         setJson4(res, 200, { data: { removed } });
         return;
       }
       if (req.method === "POST" && url.pathname === "/codex-api/telegram/configure-bot") {
-        const payload = asRecord5(await readJsonBody(req));
+        const payload = asRecord5(await readJsonBody2(req));
         const botToken = typeof payload?.botToken === "string" ? payload.botToken.trim() : "";
         const rawAllowedUserIds = Array.isArray(payload?.allowedUserIds) ? payload.allowedUserIds : [];
         if (!botToken) {
@@ -9443,7 +10907,7 @@ data: ${JSON.stringify({ ok: true })}
 
 // src/server/authMiddleware.ts
 import { randomBytes as randomBytes2, timingSafeEqual } from "crypto";
-import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir6 } from "os";
 import { dirname as dirname3, join as join7 } from "path";
 var TOKEN_COOKIE = "portal_session";
@@ -9525,10 +10989,10 @@ function readPersistedSessions() {
 }
 function persistSessions(validTokens) {
   const sessionStorePath = getSessionStorePath();
-  mkdirSync(dirname3(sessionStorePath), { recursive: true });
+  mkdirSync2(dirname3(sessionStorePath), { recursive: true });
   const tokens = Array.from(validTokens.entries()).sort((left, right) => right[1] - left[1]).slice(0, MAX_PERSISTED_TOKENS).map(([value, expiresAt]) => ({ value, expiresAt }));
   const tmpPath = `${sessionStorePath}.tmp`;
-  writeFileSync2(tmpPath, `${JSON.stringify({ tokens }, null, 2)}
+  writeFileSync3(tmpPath, `${JSON.stringify({ tokens }, null, 2)}
 `, { encoding: "utf8", mode: 384 });
   renameSync(tmpPath, sessionStorePath);
 }
@@ -10325,7 +11789,7 @@ function hasPromptedCloudflaredInstallPersisted() {
 }
 async function persistCloudflaredInstallPrompted() {
   const codexHome = getCodexHomePath();
-  mkdirSync2(codexHome, { recursive: true });
+  mkdirSync3(codexHome, { recursive: true });
   await writeFile6(getCloudflaredPromptMarkerPath(), `${Date.now()}
 `, "utf8");
 }
@@ -10411,7 +11875,7 @@ async function ensureCloudflaredInstalledLinux() {
     throw new Error(`cloudflared auto-install is not supported for Linux architecture: ${process.arch}`);
   }
   const userBinDir = join10(homedir7(), ".local", "bin");
-  mkdirSync2(userBinDir, { recursive: true });
+  mkdirSync3(userBinDir, { recursive: true });
   const destination = join10(userBinDir, "cloudflared");
   const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-${mappedArch}`;
   console.log("\ncloudflared not found. Installing to ~/.local/bin...\n");
@@ -10511,12 +11975,24 @@ Global npm install requires elevated permissions. Retrying with --prefix ${userP
 }
 function resolvePassword(input) {
   if (input === false) {
-    return void 0;
+    return { password: void 0, generated: false };
   }
   if (typeof input === "string") {
-    return input;
+    return { password: input, generated: false };
   }
-  return generatePassword();
+  return { password: generatePassword(), generated: true };
+}
+function getGeneratedPasswordPath() {
+  return join10(getCodexHomePath(), "codexui-password");
+}
+async function persistGeneratedPassword(password) {
+  const codexHome = getCodexHomePath();
+  mkdirSync3(codexHome, { recursive: true });
+  const passwordPath = getGeneratedPasswordPath();
+  await writeFile6(passwordPath, `${password}
+`, { encoding: "utf8", mode: 384 });
+  chmodSync2(passwordPath, 384);
+  return passwordPath;
 }
 function printTermuxKeepAlive(lines) {
   if (!isTermuxRuntime()) {
@@ -10535,9 +12011,8 @@ function openBrowser(url) {
   });
   child.unref();
 }
-function buildTunnelAutologinUrl(tunnelUrl, password) {
-  if (!password) return tunnelUrl;
-  return `${tunnelUrl}/password=${encodeURIComponent(password)}`;
+function buildTunnelAutologinUrl(tunnelUrl, _password) {
+  return tunnelUrl;
 }
 function parseCloudflaredUrl(chunk) {
   const urlMatch = chunk.match(/https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/g);
@@ -10732,7 +12207,9 @@ async function startServer(options) {
     console.log("\nCodex is not logged in. You can log in later via settings or run `codexui login`.\n");
   }
   const requestedPort = parseInt(options.port, 10);
-  const password = resolvePassword(options.password);
+  const passwordResolution = resolvePassword(options.password);
+  const password = passwordResolution.password;
+  const generatedPasswordPath = password && passwordResolution.generated ? await persistGeneratedPassword(password) : null;
   const { app, dispose, attachWebSocket } = createServer({ password });
   const server = createServer2(app);
   attachWebSocket(server);
@@ -10774,8 +12251,9 @@ async function startServer(options) {
   if (port !== requestedPort) {
     lines.push(`  Requested port ${String(requestedPort)} was unavailable; using ${String(port)}.`);
   }
-  if (password) {
-    lines.push(`  Password: ${password}`);
+  if (generatedPasswordPath) {
+    lines.push(`  Generated password file: ${generatedPasswordPath}`);
+    lines.push("  Use that file to retrieve the password for untrusted origins.");
   }
   const tunnelQrUrl = tunnelUrl ? buildTunnelAutologinUrl(tunnelUrl, password) : null;
   if (tunnelUrl) {