remote-codex 0.1.7 → 0.1.9

package/apps/supervisor-api/dist/index.js

@@ -5,15 +5,15 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import fs15 from "fs";
+import fs16 from "fs";
 
 // src/app.ts
 import Fastify from "fastify";
 import multipart from "@fastify/multipart";
 import websocket from "@fastify/websocket";
 import { spawn as spawn3 } from "child_process";
-import fs14 from "fs";
-import path14 from "path";
+import fs15 from "fs";
+import path15 from "path";
 import { ZodError } from "zod";
 
 // ../../packages/config/src/index.ts
@@ -32,7 +32,10 @@ var envSchema = z.object({
   DATABASE_URL: z.string().optional(),
   CODEX_HOME: z.string().optional(),
   CODEX_COMMAND: z.string().min(1).optional(),
-  CODEX_APP_SERVER_START_TIMEOUT_MS: z.coerce.number().int().positive().optional()
+  CODEX_APP_SERVER_START_TIMEOUT_MS: z.coerce.number().int().positive().optional(),
+  CLAUDE_HOME: z.string().optional(),
+  CLAUDE_COMMAND: z.string().min(1).optional(),
+  REMOTE_CODEX_ENABLED_AGENT_PROVIDERS: z.string().optional()
 });
 function resolveDatabaseUrl(nodeEnv, value) {
   if (value && value.trim()) {
@@ -48,6 +51,11 @@ function loadRuntimeConfig(env = process.env) {
   const nodeEnv = parsed.NODE_ENV ?? "development";
   const workspaceRoot = parsed.WORKSPACE_ROOT?.trim() ? path.resolve(parsed.WORKSPACE_ROOT) : os.homedir();
   const disableRequestLogging = parsed.DISABLE_REQUEST_LOGGING === void 0 ? nodeEnv === "production" : ["1", "true", "yes", "on"].includes(parsed.DISABLE_REQUEST_LOGGING.toLowerCase());
+  const enabledProviders = new Set(
+    (parsed.REMOTE_CODEX_ENABLED_AGENT_PROVIDERS ?? "codex").split(",").map((provider) => provider.trim().toLowerCase()).filter(Boolean)
+  );
+  const codexHome = parsed.CODEX_HOME?.trim() ? path.resolve(parsed.CODEX_HOME) : path.join(os.homedir(), ".codex");
+  const claudeHome = parsed.CLAUDE_HOME?.trim() ? path.resolve(parsed.CLAUDE_HOME) : path.join(os.homedir(), ".claude");
   return {
     nodeEnv,
     host: parsed.HOST ?? "127.0.0.1",
@@ -58,9 +66,21 @@ function loadRuntimeConfig(env = process.env) {
     appVersion: parsed.APP_VERSION ?? "0.1.0",
     workspaceRoot,
     databaseUrl: resolveDatabaseUrl(nodeEnv, parsed.DATABASE_URL),
-    codexHome: parsed.CODEX_HOME?.trim() ? path.resolve(parsed.CODEX_HOME) : path.join(os.homedir(), ".codex"),
-    codexCommand: parsed.CODEX_COMMAND ?? "codex",
-    codexAppServerStartTimeoutMs: parsed.CODEX_APP_SERVER_START_TIMEOUT_MS ?? 1e4
+    agentProviders: {
+      codex: {
+        provider: "codex",
+        enabled: enabledProviders.has("codex"),
+        home: codexHome,
+        command: parsed.CODEX_COMMAND ?? "codex",
+        appServerStartTimeoutMs: parsed.CODEX_APP_SERVER_START_TIMEOUT_MS ?? 1e4
+      },
+      claude: {
+        provider: "claude",
+        enabled: enabledProviders.has("claude"),
+        home: claudeHome,
+        command: parsed.CLAUDE_COMMAND ?? "claude"
+      }
+    }
   };
 }
 
@@ -1281,7 +1301,7 @@ Subquery.prototype.getSQL = function() {
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce(
-    (result2, { path: path15, field }, columnIndex) => {
+    (result2, { path: path16, field }, columnIndex) => {
       let decoder;
       if (is(field, Column)) {
         decoder = field;
@@ -1291,8 +1311,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         decoder = field.sql.decoder;
       }
       let node = result2;
-      for (const [pathChunkIndex, pathChunk] of path15.entries()) {
-        if (pathChunkIndex < path15.length - 1) {
+      for (const [pathChunkIndex, pathChunk] of path16.entries()) {
+        if (pathChunkIndex < path16.length - 1) {
           if (!(pathChunk in node)) {
             node[pathChunk] = {};
           }
@@ -1300,8 +1320,8 @@ function mapResultRow(columns, row, joinsNotNullableMap) {
         } else {
           const rawValue = row[columnIndex];
           const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
-          if (joinsNotNullableMap && is(field, Column) && path15.length === 2) {
-            const objectName = path15[0];
+          if (joinsNotNullableMap && is(field, Column) && path16.length === 2) {
+            const objectName = path16[0];
             if (!(objectName in nullifyMap)) {
               nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
             } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
@@ -5879,6 +5899,9 @@ function getActiveThreadGoalRecord(db, threadId) {
   ) ?? null;
 }
 function getThreadGoalRecordForUpsert(db, input) {
+  if (input.createNew) {
+    return null;
+  }
   if (input.localGoalId) {
     const byId = db.select().from(threadGoals).where(eq(threadGoals.id, input.localGoalId)).get();
     if (byId?.threadId === input.threadId) {
@@ -5886,7 +5909,7 @@ function getThreadGoalRecordForUpsert(db, input) {
     }
   }
   const active = getActiveThreadGoalRecord(db, input.threadId);
-  if (active) {
+  if (active && active.objective === input.objective) {
     return active;
   }
   const matchingObjective = db.select().from(threadGoals).where(
@@ -7527,7 +7550,7 @@ function extractFileChangeEntries(item) {
       isRecord2(entry.summary) ? entry.summary : null,
       isRecord2(entry.diff) ? entry.diff : null
     ].filter((candidate) => Boolean(candidate));
-    const path15 = uniqueStrings([
+    const path16 = uniqueStrings([
       stringOrNull(valueFromRecords(nestedRecords, ["path", "filePath", "targetPath"])),
       stringOrNull(
         valueFromRecords(nestedRecords, [
@@ -7574,7 +7597,7 @@ function extractFileChangeEntries(item) {
     const diffStats = explicitAdditions === 0 && explicitDeletions === 0 && diffText ? countUnifiedDiffStats(diffText) : null;
     const additions = explicitAdditions || diffStats?.additions || 0;
     const deletions = explicitDeletions || diffStats?.deletions || 0;
-    const normalizedPath = path15 ?? (diffText ? extractPathFromDiffText(diffText) : null);
+    const normalizedPath = path16 ?? (diffText ? extractPathFromDiffText(diffText) : null);
     if (!normalizedPath && additions === 0 && deletions === 0) {
       return null;
     }
@@ -8121,7 +8144,7 @@ var codexCapabilities = {
     planMode: true,
     permissionRequests: true,
     sandboxMode: true,
-    fastServiceTier: true,
+    performanceMode: true,
     goals: true
   },
   management: {
@@ -8200,6 +8223,43 @@ function mapGoal(goal) {
     rawGoal: goal
   };
 }
+function serviceTierForPerformanceMode(performanceMode) {
+  if (performanceMode === void 0) {
+    return void 0;
+  }
+  return performanceMode === "fast" ? "fast" : null;
+}
+function buildSandboxPolicy(sandboxMode, workspacePath) {
+  if (sandboxMode === void 0) {
+    return void 0;
+  }
+  switch (sandboxMode) {
+    case "danger-full-access":
+      return {
+        type: "dangerFullAccess"
+      };
+    case "read-only":
+      return {
+        type: "readOnly",
+        access: {
+          type: "fullAccess"
+        },
+        networkAccess: false
+      };
+    case "workspace-write":
+    default:
+      return {
+        type: "workspaceWrite",
+        writableRoots: workspacePath ? [workspacePath] : [],
+        readOnlyAccess: {
+          type: "fullAccess"
+        },
+        networkAccess: false,
+        excludeTmpdirEnvVar: false,
+        excludeSlashTmp: false
+      };
+  }
+}
 function mapSession(thread) {
   return {
     provider: "codex",
@@ -8465,6 +8525,8 @@ var CodexRuntimeAdapter = class extends EventEmitter3 {
         command: `node -e 'process.stdin.resume(); process.stdin.on("end", () => console.log(JSON.stringify({ systemMessage: "remote-codex hook ran" })))'`
       }
     ],
+    providerConfigFormat: "toml",
+    mcpConfigFormat: "codex-toml",
     configArchives: true,
     buildRestart: true
   };
@@ -8511,8 +8573,9 @@ var CodexRuntimeAdapter = class extends EventEmitter3 {
     if (input.sandboxMode !== void 0) {
       startInput.sandbox = input.sandboxMode;
     }
-    if (input.serviceTier !== void 0) {
-      startInput.serviceTier = input.serviceTier;
+    const serviceTier = serviceTierForPerformanceMode(input.performanceMode);
+    if (serviceTier !== void 0) {
+      startInput.serviceTier = serviceTier;
     }
     const response = await codexRuntimeCall(() => this.manager.startThread(startInput));
     return {
@@ -8535,8 +8598,9 @@ var CodexRuntimeAdapter = class extends EventEmitter3 {
     if (input.sandboxMode !== void 0) {
       resumeInput.sandbox = input.sandboxMode;
     }
-    if (input.serviceTier !== void 0) {
-      resumeInput.serviceTier = input.serviceTier;
+    const serviceTier = serviceTierForPerformanceMode(input.performanceMode);
+    if (serviceTier !== void 0) {
+      resumeInput.serviceTier = serviceTier;
     }
     const response = await codexRuntimeCall(() => this.manager.resumeThread(resumeInput));
     return {
@@ -8563,11 +8627,13 @@ var CodexRuntimeAdapter = class extends EventEmitter3 {
     if (input.collaborationMode !== void 0) {
       turnInput.collaborationMode = input.collaborationMode;
     }
-    if (input.sandboxPolicy !== void 0) {
-      turnInput.sandboxPolicy = input.sandboxPolicy;
+    const sandboxPolicy = buildSandboxPolicy(input.sandboxMode, input.workspacePath);
+    if (sandboxPolicy !== void 0) {
+      turnInput.sandboxPolicy = sandboxPolicy;
     }
-    if (input.serviceTier !== void 0) {
-      turnInput.serviceTier = input.serviceTier;
+    const serviceTier = serviceTierForPerformanceMode(input.performanceMode);
+    if (serviceTier !== void 0) {
+      turnInput.serviceTier = serviceTier;
     }
     return mapTurn2(await codexRuntimeCall(() => this.manager.startTurn(turnInput)));
   }
@@ -8640,174 +8706,713 @@ var CodexRuntimeAdapter = class extends EventEmitter3 {
   }
 };
 
-// src/codex/local-session-store.ts
-import fs4 from "fs/promises";
-import path5 from "path";
-import Database2 from "better-sqlite3";
+// src/codex/codex-management-service.ts
+import fs5 from "fs/promises";
+import path6 from "path";
 
-// src/codex/thread-title.ts
-var AUTO_THREAD_TITLE_MAX_CHARS = 15;
-function normalizeWhitespace(value) {
-  return value.replace(/\s+/g, " ").trim();
+// src/codex/codexHostConfig.ts
+import fs4 from "fs";
+import fsp from "fs/promises";
+import path5 from "path";
+var SERVICE_TIER_LINE_GLOBAL_PATTERN = /^\s*service_tier\s*=\s*("fast"|"flex"|'fast'|'flex').*\n?/gm;
+function resolveCodexConfigPath(codexHome) {
+  return path5.join(codexHome, "config.toml");
 }
-function truncateAutoThreadTitle(value) {
-  const normalized = normalizeWhitespace(value);
-  if (!normalized) {
-    return "";
-  }
-  const characters = Array.from(normalized);
-  if (characters.length <= AUTO_THREAD_TITLE_MAX_CHARS) {
-    return normalized;
-  }
-  return `${characters.slice(0, AUTO_THREAD_TITLE_MAX_CHARS).join("")}...`;
+function parseCodexServiceTier(content) {
+  const match = content.match(
+    /^\s*service_tier\s*=\s*["'](?<tier>fast)["']\s*$/m
+  );
+  const tier = match?.groups?.tier;
+  return tier === "fast" ? tier : null;
 }
-
-// src/codex/local-session-store.ts
-function basenameFromPath(absPath) {
-  const normalized = absPath.replace(/[\\/]+$/, "");
-  return normalized.split(/[\\/]/).at(-1) ?? normalized;
+function isFastModeEnabledFromConfig(content) {
+  return parseCodexServiceTier(content) === "fast";
 }
-function summarizeTitleFromTurns(turns) {
-  const firstUserMessage = turns.flatMap((turn) => turn.items).find((item) => item.kind === "userMessage" && item.text.trim());
-  if (!firstUserMessage) {
-    return null;
+function readCodexFastModeSync(codexHome) {
+  try {
+    const content = fs4.readFileSync(resolveCodexConfigPath(codexHome), "utf8");
+    return isFastModeEnabledFromConfig(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
   }
-  return truncateAutoThreadTitle(firstUserMessage.text);
-}
-function createHistoryItemId(turnId, prefix, index) {
-  return `${turnId}-${prefix}-${index}`;
 }
-function finalizeTurn(turn, turns) {
-  if (!turn || turn.items.length === 0) {
-    return;
+function upsertCodexServiceTier(content, enabled) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const withoutServiceTier = normalized.replace(
+    SERVICE_TIER_LINE_GLOBAL_PATTERN,
+    ""
+  );
+  if (!enabled) {
+    return withoutServiceTier.replace(/\n{3,}/g, "\n\n").trimEnd() + (withoutServiceTier.trim() ? "\n" : "");
   }
-  turns.push({
-    id: turn.id,
-    startedAt: turn.startedAt,
-    status: turn.status,
-    error: turn.error,
-    items: turn.items
-  });
+  const nextLine = 'service_tier = "fast"';
+  if (!withoutServiceTier.trim()) {
+    return `${nextLine}
+`;
+  }
+  const firstSectionMatch = withoutServiceTier.match(/^\s*\[[^\]]+\]/m);
+  if (!firstSectionMatch || firstSectionMatch.index === void 0) {
+    return withoutServiceTier.endsWith("\n") ? `${withoutServiceTier}${nextLine}
+` : `${withoutServiceTier}
+${nextLine}
+`;
+  }
+  const beforeFirstSection = withoutServiceTier.slice(0, firstSectionMatch.index).trimEnd();
+  const afterFirstSection = withoutServiceTier.slice(firstSectionMatch.index).replace(/^\n+/, "");
+  return beforeFirstSection ? `${beforeFirstSection}
+${nextLine}
+${afterFirstSection}` : `${nextLine}
+${afterFirstSection}`;
 }
-function parseTranscript(contents) {
-  const turns = [];
-  let cwd = null;
-  let currentTurn = null;
-  let fallbackTurnCount = 0;
-  let agentItemCount = 0;
-  let userItemCount = 0;
-  const ensureCurrentTurn = (timestamp) => {
-    if (currentTurn) {
-      return currentTurn;
-    }
-    fallbackTurnCount += 1;
-    currentTurn = {
-      id: `local-turn-${fallbackTurnCount}`,
-      startedAt: timestamp ?? null,
-      status: "inProgress",
-      error: null,
-      items: []
-    };
-    agentItemCount = 0;
-    userItemCount = 0;
-    return currentTurn;
-  };
-  for (const line of contents.split("\n")) {
-    if (!line.trim()) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (entry.type === "session_meta") {
-      const payload2 = entry.payload ?? {};
-      if (typeof payload2.cwd === "string" && payload2.cwd.trim()) {
-        cwd = payload2.cwd;
-      }
-      continue;
-    }
-    if (entry.type !== "event_msg") {
-      continue;
-    }
-    const payload = entry.payload ?? {};
-    const payloadType = payload.type;
-    if (payloadType === "task_started") {
-      finalizeTurn(currentTurn, turns);
-      currentTurn = {
-        id: typeof payload.turn_id === "string" && payload.turn_id.trim() ? payload.turn_id : `local-turn-${fallbackTurnCount + 1}`,
-        startedAt: entry.timestamp ?? null,
-        status: "inProgress",
-        error: null,
-        items: []
-      };
-      agentItemCount = 0;
-      userItemCount = 0;
-      continue;
-    }
-    if (payloadType === "user_message" && typeof payload.message === "string") {
-      const turn = ensureCurrentTurn(entry.timestamp);
-      userItemCount += 1;
-      turn.items.push({
-        id: createHistoryItemId(turn.id, "user", userItemCount),
-        kind: "userMessage",
-        text: payload.message
-      });
-      continue;
-    }
-    if (payloadType === "agent_message" && typeof payload.message === "string") {
-      const turn = ensureCurrentTurn(entry.timestamp);
-      agentItemCount += 1;
-      turn.items.push({
-        id: createHistoryItemId(turn.id, "agent", agentItemCount),
-        kind: "agentMessage",
-        text: payload.message,
-        status: typeof payload.phase === "string" ? payload.phase : null
-      });
-      continue;
-    }
-    if (payloadType === "task_complete") {
-      const turn = ensureCurrentTurn(entry.timestamp);
-      turn.status = turn.error ? "failed" : "completed";
-      finalizeTurn(turn, turns);
-      currentTurn = null;
-      continue;
-    }
-    if (payloadType === "error") {
-      const turn = ensureCurrentTurn(entry.timestamp);
-      turn.status = "failed";
-      turn.error = typeof payload.message === "string" ? payload.message : "Local Codex session failed.";
+async function writeCodexFastMode(codexHome, enabled) {
+  const configPath = resolveCodexConfigPath(codexHome);
+  let current = "";
+  try {
+    current = await fsp.readFile(configPath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
     }
   }
-  finalizeTurn(currentTurn, turns);
-  return {
-    cwd,
-    title: summarizeTitleFromTurns(turns),
-    turns
-  };
+  const next = upsertCodexServiceTier(current, enabled);
+  await fsp.mkdir(path5.dirname(configPath), { recursive: true });
+  await fsp.writeFile(configPath, next, "utf8");
+  return next;
 }
-async function fileExists(filePath) {
-  try {
-    await fs4.access(filePath);
-    return true;
-  } catch {
+function isCodexFeatureEnabledFromConfig(content, featureName) {
+  const escaped = featureName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const featuresMatch = content.match(/^[^\S\r\n]*\[features\][^\S\r\n]*$/m);
+  if (!featuresMatch || featuresMatch.index === void 0) {
     return false;
   }
+  const sectionStart = featuresMatch.index + featuresMatch[0].length;
+  const nextSectionMatch = content.slice(sectionStart).match(/^[^\S\r\n]*\[[^\]\r\n]+\][^\S\r\n]*$/m);
+  const sectionEnd = nextSectionMatch && nextSectionMatch.index !== void 0 ? sectionStart + nextSectionMatch.index : content.length;
+  const featuresBody = content.slice(sectionStart, sectionEnd);
+  return new RegExp(`^\\s*${escaped}\\s*=\\s*true\\s*(?:#.*)?$`, "m").test(featuresBody);
 }
-var LocalCodexSessionStore = class {
-  constructor(codexHome) {
-    this.codexHome = codexHome;
-  }
-  codexHome;
-  async findSession(sessionId) {
+async function readCodexFeatureFlag(codexHome, featureName) {
+  try {
+    const content = await fsp.readFile(resolveCodexConfigPath(codexHome), "utf8");
+    return isCodexFeatureEnabledFromConfig(content, featureName);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function upsertCodexFeatureFlag(content, featureName, enabled) {
+  const normalized = content.replace(/\r\n/g, "\n");
+  const escaped = featureName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const featuresMatch = normalized.match(/^[^\S\r\n]*\[features\][^\S\r\n]*$/m);
+  const nextLine = `${featureName} = ${enabled ? "true" : "false"}`;
+  if (!featuresMatch || featuresMatch.index === void 0) {
+    const prefix = normalized.trimEnd();
+    return prefix ? `${prefix}
+
+[features]
+${nextLine}
+` : `[features]
+${nextLine}
+`;
+  }
+  const sectionStart = featuresMatch.index + featuresMatch[0].length;
+  const nextSectionMatch = normalized.slice(sectionStart).match(/^[^\S\r\n]*\[[^\]\r\n]+\][^\S\r\n]*$/m);
+  const sectionEnd = nextSectionMatch && nextSectionMatch.index !== void 0 ? sectionStart + nextSectionMatch.index : normalized.length;
+  const beforeSectionBody = normalized.slice(0, sectionStart);
+  const sectionBody = normalized.slice(sectionStart, sectionEnd);
+  const afterSection = normalized.slice(sectionEnd);
+  const flagPattern = new RegExp(
+    `(^[^\\S\\r\\n]*)${escaped}[^\\S\\r\\n]*=[^\\S\\r\\n]*(true|false)[^\\S\\r\\n]*(?:#.*)?$`,
+    "m"
+  );
+  if (flagPattern.test(sectionBody)) {
+    return beforeSectionBody + sectionBody.replace(flagPattern, `$1${nextLine}`) + afterSection;
+  }
+  const bodyWithFlag = `${sectionBody.replace(/\n*$/, "")}
+${nextLine}
+`;
+  const normalizedAfterSection = afterSection.startsWith("\n") ? afterSection : `
+${afterSection}`;
+  return beforeSectionBody + bodyWithFlag + normalizedAfterSection;
+}
+async function writeCodexFeatureFlag(codexHome, featureName, enabled) {
+  const configPath = resolveCodexConfigPath(codexHome);
+  let current = "";
+  try {
+    current = await fsp.readFile(configPath, "utf8");
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+  const next = upsertCodexFeatureFlag(current, featureName, enabled);
+  await fsp.mkdir(path5.dirname(configPath), { recursive: true });
+  await fsp.writeFile(configPath, next, "utf8");
+  return next;
+}
+
+// src/codex/runtime-errors.ts
+function unwrapCodexJsonRpcError(error) {
+  if (error instanceof JsonRpcClientError) {
+    return error;
+  }
+  if (error instanceof AgentRuntimeError && error.provider === "codex") {
+    return error.cause instanceof JsonRpcClientError ? error.cause : null;
+  }
+  return null;
+}
+function isCodexRemoteError(error) {
+  const codexError = unwrapCodexJsonRpcError(error);
+  return codexError?.code === "remote_error" ? codexError : null;
+}
+function isCodexRuntimeRequestError(error) {
+  return Boolean(unwrapCodexJsonRpcError(error));
+}
+function isRemoteThreadBootstrapError(error) {
+  const codexError = isCodexRemoteError(error);
+  if (!codexError) {
+    return false;
+  }
+  return codexError.message.includes("includeTurns is unavailable before first user message") || codexError.message.includes("is not materialized yet") || codexError.message.includes("no rollout found for thread id") || codexError.message.includes("failed to load rollout") || codexError.message.includes("rollout at") && codexError.message.includes("is empty");
+}
+function isUnsupportedHooksListError(error) {
+  const codexError = isCodexRemoteError(error);
+  if (!codexError) {
+    return false;
+  }
+  const remoteCode = codexError.details?.code;
+  const message = codexError.message.toLowerCase();
+  return remoteCode === -32601 || message.includes("endpoint not found") || message.includes("method not found") || message.includes("hooks/list") && message.includes("not found");
+}
+function parseTurnSteerRace(error) {
+  const codexError = isCodexRemoteError(error);
+  if (!codexError) {
+    return null;
+  }
+  if (codexError.message === "no active turn to steer") {
+    return { type: "missing" };
+  }
+  const mismatchPrefix = "expected active turn id `";
+  const mismatchSeparator = "` but found `";
+  if (!codexError.message.startsWith(mismatchPrefix)) {
+    return null;
+  }
+  const actualTurnId = codexError.message.slice(mismatchPrefix.length).split(mismatchSeparator)[1]?.replace(/`$/, "");
+  if (!actualTurnId) {
+    return null;
+  }
+  return {
+    type: "turnIdMismatch",
+    actualTurnId
+  };
+}
+
+// src/codex/codex-management-service.ts
+var GOAL_FEATURE_DISABLED_MESSAGE = "Codex /goal is experimental. Enable it by adding `goals = true` under `[features]` in ~/.codex/config.toml, then restart the Codex app-server.";
+var HOOK_EVENT_JSON_KEYS = {
+  preToolUse: "PreToolUse",
+  permissionRequest: "PermissionRequest",
+  postToolUse: "PostToolUse",
+  preCompact: "PreCompact",
+  postCompact: "PostCompact",
+  sessionStart: "SessionStart",
+  userPromptSubmit: "UserPromptSubmit",
+  stop: "Stop"
+};
+var HOOK_EVENT_DTO_KEYS = Object.fromEntries(
+  Object.entries(HOOK_EVENT_JSON_KEYS).map(([dtoKey, jsonKey]) => [jsonKey, dtoKey])
+);
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeHooksJson(value) {
+  if (!isRecord4(value) || !isRecord4(value.hooks)) {
+    return { hooks: {} };
+  }
+  const hooks = {};
+  for (const [eventName, groups] of Object.entries(value.hooks)) {
+    hooks[eventName] = Array.isArray(groups) ? groups : [];
+  }
+  return { ...value, hooks };
+}
+function readJsonFileOrDefault(filePath) {
+  return fs5.readFile(filePath, "utf8").then((raw) => {
+    if (!raw.trim()) {
+      return { hooks: {} };
+    }
+    return normalizeHooksJson(JSON.parse(raw));
+  }).catch((error) => {
+    if (error.code === "ENOENT") {
+      return { hooks: {} };
+    }
+    throw error;
+  });
+}
+function validateHookInput(input) {
+  if (!HOOK_EVENT_JSON_KEYS[input.eventName]) {
+    throw new HttpError(400, {
+      code: "bad_request",
+      message: "Unsupported hook event."
+    });
+  }
+  if (input.scope !== "global" && input.scope !== "project") {
+    throw new HttpError(400, {
+      code: "bad_request",
+      message: "Hook scope must be global or project."
+    });
+  }
+  if (!input.command.trim()) {
+    throw new HttpError(400, {
+      code: "bad_request",
+      message: "Hook command cannot be empty."
+    });
+  }
+  if (input.timeoutSec !== void 0 && input.timeoutSec !== null && (!Number.isInteger(input.timeoutSec) || input.timeoutSec <= 0 || input.timeoutSec > 86400)) {
+    throw new HttpError(400, {
+      code: "bad_request",
+      message: "Hook timeout must be a positive number of seconds."
+    });
+  }
+}
+function hooksPathForInput(codexHome, workspacePath, input) {
+  return input.scope === "global" ? path6.join(codexHome, "hooks.json") : path6.join(workspacePath, ".codex", "hooks.json");
+}
+function hookInputMatches(group, handler, input) {
+  if (!isRecord4(group) || !isRecord4(handler)) {
+    return false;
+  }
+  const matcher = typeof group.matcher === "string" ? group.matcher : null;
+  const handlerCommand = typeof handler.command === "string" ? handler.command : "";
+  const handlerTimeout = typeof handler.timeout === "number" && Number.isFinite(handler.timeout) ? handler.timeout : null;
+  const handlerStatusMessage = typeof handler.statusMessage === "string" ? handler.statusMessage : null;
+  return handler.type === "command" && (input.matcher?.trim() || null) === matcher && input.command.trim() === handlerCommand && (input.timeoutSec ?? null) === handlerTimeout && (input.statusMessage?.trim() || null) === handlerStatusMessage;
+}
+function hookMatchesInput(hook, input) {
+  return hook.source === input.scope && hook.eventName === input.eventName && (hook.matcher ?? null) === (input.matcher ?? null) && hook.command === input.command && (input.timeoutSec == null || hook.timeoutSec === input.timeoutSec) && (hook.statusMessage ?? null) === (input.statusMessage ?? null);
+}
+async function findOfficialHookForInput(runtime, workspacePath, input) {
+  if (!runtime.listHooks) {
+    return null;
+  }
+  const [entry] = await runtime.listHooks({
+    cwds: [workspacePath]
+  });
+  const officialHooks = (entry?.hooks ?? []).map((hook) => ({
+    key: hook.key,
+    eventName: hook.eventName,
+    handlerType: hook.handlerType,
+    matcher: hook.matcher,
+    command: hook.command,
+    timeoutSec: hook.timeoutSec,
+    statusMessage: hook.statusMessage,
+    sourcePath: hook.sourcePath,
+    source: hook.source,
+    pluginId: hook.pluginId,
+    displayOrder: hook.displayOrder,
+    enabled: hook.enabled,
+    isManaged: hook.isManaged,
+    currentHash: hook.currentHash,
+    trustStatus: hook.trustStatus
+  }));
+  return officialHooks.find((hook) => hookMatchesInput(hook, input)) ?? null;
+}
+async function trustHookForInput(runtime, workspacePath, input) {
+  const hook = await findOfficialHookForInput(runtime, workspacePath, input);
+  if (!runtime.setHookTrust || !hook || !hook.key || !hook.currentHash || hook.isManaged) {
+    return;
+  }
+  await runtime.setHookTrust({
+    key: hook.key,
+    trustedHash: hook.currentHash
+  });
+}
+var CodexManagementService = class {
+  constructor(codexHome) {
+    this.codexHome = codexHome;
+  }
+  codexHome;
+  readFastMode() {
+    return readCodexFastModeSync(this.codexHome);
+  }
+  writeFastMode(enabled) {
+    return writeCodexFastMode(this.codexHome, enabled);
+  }
+  mapGoalError(error) {
+    const codexError = unwrapCodexJsonRpcError(error);
+    if (codexError) {
+      const remoteMessage = codexError.message || "";
+      if (remoteMessage.toLowerCase().includes("goals feature is disabled")) {
+        throw new HttpError(409, {
+          code: "goal_feature_disabled",
+          message: GOAL_FEATURE_DISABLED_MESSAGE
+        });
+      }
+      throw new HttpError(502, {
+        code: "provider_goal_error",
+        message: remoteMessage || "Provider goal operation failed.",
+        details: {
+          provider: "codex"
+        }
+      });
+    }
+    throw error;
+  }
+  async ensureGoalsFeatureEnabled(runtime) {
+    try {
+      if (await readCodexFeatureFlag(this.codexHome, "goals")) {
+        return;
+      }
+      await writeCodexFeatureFlag(this.codexHome, "goals", true);
+      await runtime.stop();
+      await runtime.start();
+    } catch (error) {
+      if (isCodexRuntimeRequestError(error)) {
+        throw new HttpError(409, {
+          code: "goal_feature_disabled",
+          message: GOAL_FEATURE_DISABLED_MESSAGE
+        });
+      }
+      throw error;
+    }
+  }
+  isRuntimeRequestError(error) {
+    return isCodexRuntimeRequestError(error);
+  }
+  async writeHookEntry(runtime, workspacePath, input) {
+    validateHookInput(input);
+    const hooksPath = hooksPathForInput(this.codexHome, workspacePath, input);
+    const config = await readJsonFileOrDefault(hooksPath);
+    const eventKey = HOOK_EVENT_JSON_KEYS[input.eventName];
+    const matcher = input.matcher?.trim() || null;
+    const handler = {
+      type: "command",
+      command: input.command.trim()
+    };
+    if (input.timeoutSec !== void 0 && input.timeoutSec !== null) {
+      handler.timeout = input.timeoutSec;
+    }
+    if (input.statusMessage?.trim()) {
+      handler.statusMessage = input.statusMessage.trim();
+    }
+    const group = {
+      hooks: [handler]
+    };
+    if (matcher) {
+      group.matcher = matcher;
+    }
+    const currentGroups = Array.isArray(config.hooks[eventKey]) ? config.hooks[eventKey] : [];
+    config.hooks[eventKey] = [...currentGroups, group];
+    await fs5.mkdir(path6.dirname(hooksPath), { recursive: true });
+    await fs5.writeFile(hooksPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    await trustHookForInput(runtime, workspacePath, input);
+  }
+  async updateHookEntry(runtime, workspacePath, input) {
+    validateHookInput(input);
+    validateHookInput(input.target);
+    if (input.scope !== input.target.scope) {
+      throw new HttpError(400, {
+        code: "bad_request",
+        message: "Hook scope cannot be changed while editing."
+      });
+    }
+    const hooksPath = hooksPathForInput(this.codexHome, workspacePath, input);
+    const config = await readJsonFileOrDefault(hooksPath);
+    const targetEventKey = HOOK_EVENT_JSON_KEYS[input.target.eventName];
+    const nextEventKey = HOOK_EVENT_JSON_KEYS[input.eventName];
+    const currentGroups = Array.isArray(config.hooks[targetEventKey]) ? config.hooks[targetEventKey] : [];
+    let replacementGroup = null;
+    config.hooks[targetEventKey] = currentGroups.map((group) => {
+      if (replacementGroup || !isRecord4(group) || !Array.isArray(group.hooks)) {
+        return group;
+      }
+      const hookIndex = group.hooks.findIndex(
+        (handler2) => hookInputMatches(group, handler2, input.target)
+      );
+      if (hookIndex < 0) {
+        return group;
+      }
+      const handler = {
+        type: "command",
+        command: input.command.trim()
+      };
+      if (input.timeoutSec !== void 0 && input.timeoutSec !== null) {
+        handler.timeout = input.timeoutSec;
+      }
+      if (input.statusMessage?.trim()) {
+        handler.statusMessage = input.statusMessage.trim();
+      }
+      replacementGroup = {
+        hooks: [handler]
+      };
+      const matcher = input.matcher?.trim() || null;
+      if (matcher) {
+        replacementGroup.matcher = matcher;
+      }
+      if (targetEventKey !== nextEventKey) {
+        const remainingHooks = group.hooks.filter((_, index) => index !== hookIndex);
+        return {
+          ...group,
+          hooks: remainingHooks
+        };
+      }
+      return {
+        ...replacementGroup,
+        hooks: group.hooks.map(
+          (existing, index) => index === hookIndex ? replacementGroup.hooks[0] : existing
+        )
+      };
+    }).filter((group) => {
+      if (!isRecord4(group) || !Array.isArray(group.hooks)) {
+        return true;
+      }
+      return group.hooks.length > 0;
+    });
+    if (!replacementGroup) {
+      throw new HttpError(404, {
+        code: "not_found",
+        message: "Hook was not found in hooks.json."
+      });
+    }
+    if (targetEventKey !== nextEventKey) {
+      if (config.hooks[targetEventKey]?.length === 0) {
+        delete config.hooks[targetEventKey];
+      }
+      const nextGroups = Array.isArray(config.hooks[nextEventKey]) ? config.hooks[nextEventKey] : [];
+      config.hooks[nextEventKey] = [...nextGroups, replacementGroup];
+    }
+    await fs5.mkdir(path6.dirname(hooksPath), { recursive: true });
+    await fs5.writeFile(hooksPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    await trustHookForInput(runtime, workspacePath, input);
+  }
+  async readLocalHookDtos(input) {
+    const config = await readJsonFileOrDefault(input.hooksPath);
+    const hooks = [];
+    for (const [eventKey, groups] of Object.entries(config.hooks)) {
+      const eventName = HOOK_EVENT_DTO_KEYS[eventKey];
+      if (!eventName || !Array.isArray(groups)) {
+        continue;
+      }
+      groups.forEach((group, groupIndex) => {
+        if (!isRecord4(group) || !Array.isArray(group.hooks)) {
+          return;
+        }
+        const matcher = typeof group.matcher === "string" ? group.matcher : null;
+        group.hooks.forEach((handler, handlerIndex) => {
+          if (!isRecord4(handler) || handler.type !== "command") {
+            return;
+          }
+          const command = typeof handler.command === "string" ? handler.command : null;
+          if (!command) {
+            return;
+          }
+          const timeoutSec = typeof handler.timeout === "number" && Number.isFinite(handler.timeout) ? handler.timeout : 600;
+          const statusMessage = typeof handler.statusMessage === "string" ? handler.statusMessage : null;
+          const key = `${input.source}:${input.hooksPath}:${eventKey}:${groupIndex}:${handlerIndex}`;
+          hooks.push({
+            key,
+            eventName,
+            handlerType: "command",
+            matcher,
+            command,
+            timeoutSec,
+            statusMessage,
+            sourcePath: input.hooksPath,
+            source: input.source,
+            pluginId: null,
+            displayOrder: input.displayOffset + hooks.length,
+            enabled: true,
+            isManaged: false,
+            currentHash: "",
+            trustStatus: "untrusted"
+          });
+        });
+      });
+    }
+    return hooks;
+  }
+  hooksPaths(workspacePath) {
+    return {
+      globalHooksPath: path6.join(this.codexHome, "hooks.json"),
+      projectHooksPath: path6.join(workspacePath, ".codex", "hooks.json")
+    };
+  }
+};
+
+// src/codex/local-session-store.ts
+import fs6 from "fs/promises";
+import path7 from "path";
+import Database2 from "better-sqlite3";
+
+// src/codex/thread-title.ts
+var AUTO_THREAD_TITLE_MAX_CHARS = 15;
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncateAutoThreadTitle(value) {
+  const normalized = normalizeWhitespace(value);
+  if (!normalized) {
+    return "";
+  }
+  const characters = Array.from(normalized);
+  if (characters.length <= AUTO_THREAD_TITLE_MAX_CHARS) {
+    return normalized;
+  }
+  return `${characters.slice(0, AUTO_THREAD_TITLE_MAX_CHARS).join("")}...`;
+}
+
+// src/codex/local-session-store.ts
+function basenameFromPath(absPath) {
+  const normalized = absPath.replace(/[\\/]+$/, "");
+  return normalized.split(/[\\/]/).at(-1) ?? normalized;
+}
+function summarizeTitleFromTurns(turns) {
+  const firstUserMessage = turns.flatMap((turn) => turn.items).find((item) => item.kind === "userMessage" && item.text.trim());
+  if (!firstUserMessage) {
+    return null;
+  }
+  return truncateAutoThreadTitle(firstUserMessage.text);
+}
+function createHistoryItemId(turnId, prefix, index) {
+  return `${turnId}-${prefix}-${index}`;
+}
+function finalizeTurn(turn, turns) {
+  if (!turn || turn.items.length === 0) {
+    return;
+  }
+  turns.push({
+    id: turn.id,
+    startedAt: turn.startedAt,
+    status: turn.status,
+    error: turn.error,
+    items: turn.items
+  });
+}
+function parseTranscript(contents) {
+  const turns = [];
+  let cwd = null;
+  let currentTurn = null;
+  let fallbackTurnCount = 0;
+  let agentItemCount = 0;
+  let userItemCount = 0;
+  const ensureCurrentTurn = (timestamp) => {
+    if (currentTurn) {
+      return currentTurn;
+    }
+    fallbackTurnCount += 1;
+    currentTurn = {
+      id: `local-turn-${fallbackTurnCount}`,
+      startedAt: timestamp ?? null,
+      status: "inProgress",
+      error: null,
+      items: []
+    };
+    agentItemCount = 0;
+    userItemCount = 0;
+    return currentTurn;
+  };
+  for (const line of contents.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry.type === "session_meta") {
+      const payload2 = entry.payload ?? {};
+      if (typeof payload2.cwd === "string" && payload2.cwd.trim()) {
+        cwd = payload2.cwd;
+      }
+      continue;
+    }
+    if (entry.type !== "event_msg") {
+      continue;
+    }
+    const payload = entry.payload ?? {};
+    const payloadType = payload.type;
+    if (payloadType === "task_started") {
+      finalizeTurn(currentTurn, turns);
+      currentTurn = {
+        id: typeof payload.turn_id === "string" && payload.turn_id.trim() ? payload.turn_id : `local-turn-${fallbackTurnCount + 1}`,
+        startedAt: entry.timestamp ?? null,
+        status: "inProgress",
+        error: null,
+        items: []
+      };
+      agentItemCount = 0;
+      userItemCount = 0;
+      continue;
+    }
+    if (payloadType === "user_message" && typeof payload.message === "string") {
+      const turn = ensureCurrentTurn(entry.timestamp);
+      userItemCount += 1;
+      turn.items.push({
+        id: createHistoryItemId(turn.id, "user", userItemCount),
+        kind: "userMessage",
+        text: payload.message
+      });
+      continue;
+    }
+    if (payloadType === "agent_message" && typeof payload.message === "string") {
+      const turn = ensureCurrentTurn(entry.timestamp);
+      agentItemCount += 1;
+      turn.items.push({
+        id: createHistoryItemId(turn.id, "agent", agentItemCount),
+        kind: "agentMessage",
+        text: payload.message,
+        status: typeof payload.phase === "string" ? payload.phase : null
+      });
+      continue;
+    }
+    if (payloadType === "task_complete") {
+      const turn = ensureCurrentTurn(entry.timestamp);
+      turn.status = turn.error ? "failed" : "completed";
+      finalizeTurn(turn, turns);
+      currentTurn = null;
+      continue;
+    }
+    if (payloadType === "error") {
+      const turn = ensureCurrentTurn(entry.timestamp);
+      turn.status = "failed";
+      turn.error = typeof payload.message === "string" ? payload.message : "Local Codex session failed.";
+    }
+  }
+  finalizeTurn(currentTurn, turns);
+  return {
+    cwd,
+    title: summarizeTitleFromTurns(turns),
+    turns
+  };
+}
+async function fileExists(filePath) {
+  try {
+    await fs6.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var LocalCodexSessionStore = class {
+  constructor(codexHome) {
+    this.codexHome = codexHome;
+  }
+  codexHome;
+  async findSession(sessionId) {
     const stateRecord = await this.findSessionInStateDatabases(sessionId);
     const transcriptPath = await this.resolveTranscriptPath(
       stateRecord?.rolloutPath ?? null,
       sessionId
     );
-    const transcript = transcriptPath ? parseTranscript(await fs4.readFile(transcriptPath, "utf8")) : null;
+    const transcript = transcriptPath ? parseTranscript(await fs6.readFile(transcriptPath, "utf8")) : null;
     const cwd = stateRecord?.cwd ?? transcript?.cwd ?? null;
     if (!cwd) {
       return null;
@@ -8824,14 +9429,14 @@ var LocalCodexSessionStore = class {
   async findSessionInStateDatabases(sessionId) {
     let entries;
     try {
-      entries = await fs4.readdir(this.codexHome);
+      entries = await fs6.readdir(this.codexHome);
     } catch {
       return null;
     }
     const stateFiles = await Promise.all(
       entries.filter((entry) => /^state_\d+\.sqlite$/i.test(entry)).map(async (entry) => {
-        const absPath = path5.join(this.codexHome, entry);
-        const stats = await fs4.stat(absPath);
+        const absPath = path7.join(this.codexHome, entry);
+        const stats = await fs6.stat(absPath);
         return {
           absPath,
           mtimeMs: stats.mtimeMs
@@ -8870,22 +9475,22 @@ var LocalCodexSessionStore = class {
   }
   async resolveTranscriptPath(rolloutPath, sessionId) {
     if (rolloutPath?.trim()) {
-      const absolutePath = path5.isAbsolute(rolloutPath) ? rolloutPath : path5.resolve(this.codexHome, rolloutPath);
+      const absolutePath = path7.isAbsolute(rolloutPath) ? rolloutPath : path7.resolve(this.codexHome, rolloutPath);
       if (await fileExists(absolutePath)) {
         return absolutePath;
       }
     }
-    return this.findTranscriptFile(path5.join(this.codexHome, "sessions"), sessionId);
+    return this.findTranscriptFile(path7.join(this.codexHome, "sessions"), sessionId);
   }
   async findTranscriptFile(directory, sessionId) {
     let entries;
     try {
-      entries = await fs4.readdir(directory, { withFileTypes: true });
+      entries = await fs6.readdir(directory, { withFileTypes: true });
     } catch {
       return null;
     }
     for (const entry of entries) {
-      const absPath = path5.join(directory, entry.name);
+      const absPath = path7.join(directory, entry.name);
       if (entry.isDirectory()) {
         const nested = await this.findTranscriptFile(absPath, sessionId);
         if (nested) {
@@ -8903,23 +9508,33 @@ var LocalCodexSessionStore = class {
 
 // src/agent-runtime-bootstrap.ts
 function createAgentRuntimeBootstrap(config) {
-  const codexRuntime = new CodexRuntimeAdapter(
+  const runtimes = [];
+  const providerHostHomes = {};
+  const codexConfig = config.agentProviders.codex;
+  const codexRuntime = codexConfig.enabled ? new CodexRuntimeAdapter(
     new CodexAppServerManager({
-      command: config.codexCommand,
-      startupTimeoutMs: config.codexAppServerStartTimeoutMs,
+      command: codexConfig.command,
+      startupTimeoutMs: codexConfig.appServerStartTimeoutMs,
       clientInfo: {
         name: "remote-codex-supervisor",
         title: config.appName,
         version: config.appVersion
       }
     })
-  );
+  ) : null;
+  if (codexRuntime) {
+    runtimes.push(codexRuntime);
+    providerHostHomes.codex = codexConfig.home;
+  }
+  const claudeConfig = config.agentProviders.claude;
+  if (claudeConfig.enabled) {
+    providerHostHomes.claude = claudeConfig.home;
+  }
   return {
-    agentRuntimes: new AgentRuntimeRegistry([codexRuntime]),
-    localCodexSessionStore: new LocalCodexSessionStore(config.codexHome),
-    providerHostHomes: {
-      codex: config.codexHome
-    }
+    agentRuntimes: new AgentRuntimeRegistry(runtimes),
+    localCodexSessionStore: new LocalCodexSessionStore(codexConfig.home),
+    codexManagement: new CodexManagementService(codexConfig.home),
+    providerHostHomes
   };
 }
 
@@ -8948,11 +9563,11 @@ var SupervisorEventBus = class extends EventEmitter4 {
 
 // src/thread-service.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 
 // src/exports/thread-pdf-export.ts
-import fs5 from "fs";
+import fs7 from "fs";
 import puppeteer from "puppeteer-core";
 import { marked } from "marked";
 var MAX_TEXT_CHARS = 12e3;
@@ -8985,10 +9600,10 @@ function renderEmbeddedCjkFontCss() {
   embeddedCjkFontCss = "";
   for (const candidate of EMBEDDED_CJK_FONT_CANDIDATES) {
     try {
-      if (!fs5.existsSync(candidate.path)) {
+      if (!fs7.existsSync(candidate.path)) {
         continue;
       }
-      const font = fs5.readFileSync(candidate.path);
+      const font = fs7.readFileSync(candidate.path);
       embeddedCjkFontCss = `
       @font-face {
         font-family: "RemoteCodexCJK";
@@ -10030,208 +10645,6 @@ async function launchPdfBrowser() {
   }
 }
 
-// src/codex/codexHostConfig.ts
-import fs6 from "fs";
-import fsp from "fs/promises";
-import path6 from "path";
-var SERVICE_TIER_LINE_GLOBAL_PATTERN = /^\s*service_tier\s*=\s*("fast"|"flex"|'fast'|'flex').*\n?/gm;
-function resolveCodexConfigPath(codexHome) {
-  return path6.join(codexHome, "config.toml");
-}
-function parseCodexServiceTier(content) {
-  const match = content.match(
-    /^\s*service_tier\s*=\s*["'](?<tier>fast)["']\s*$/m
-  );
-  const tier = match?.groups?.tier;
-  return tier === "fast" ? tier : null;
-}
-function isFastModeEnabledFromConfig(content) {
-  return parseCodexServiceTier(content) === "fast";
-}
-function readCodexFastModeSync(codexHome) {
-  try {
-    const content = fs6.readFileSync(resolveCodexConfigPath(codexHome), "utf8");
-    return isFastModeEnabledFromConfig(content);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-function upsertCodexServiceTier(content, enabled) {
-  const normalized = content.replace(/\r\n/g, "\n");
-  const withoutServiceTier = normalized.replace(
-    SERVICE_TIER_LINE_GLOBAL_PATTERN,
-    ""
-  );
-  if (!enabled) {
-    return withoutServiceTier.replace(/\n{3,}/g, "\n\n").trimEnd() + (withoutServiceTier.trim() ? "\n" : "");
-  }
-  const nextLine = 'service_tier = "fast"';
-  if (!withoutServiceTier.trim()) {
-    return `${nextLine}
-`;
-  }
-  const firstSectionMatch = withoutServiceTier.match(/^\s*\[[^\]]+\]/m);
-  if (!firstSectionMatch || firstSectionMatch.index === void 0) {
-    return withoutServiceTier.endsWith("\n") ? `${withoutServiceTier}${nextLine}
-` : `${withoutServiceTier}
-${nextLine}
-`;
-  }
-  const beforeFirstSection = withoutServiceTier.slice(0, firstSectionMatch.index).trimEnd();
-  const afterFirstSection = withoutServiceTier.slice(firstSectionMatch.index).replace(/^\n+/, "");
-  return beforeFirstSection ? `${beforeFirstSection}
-${nextLine}
-${afterFirstSection}` : `${nextLine}
-${afterFirstSection}`;
-}
-async function writeCodexFastMode(codexHome, enabled) {
-  const configPath = resolveCodexConfigPath(codexHome);
-  let current = "";
-  try {
-    current = await fsp.readFile(configPath, "utf8");
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  const next = upsertCodexServiceTier(current, enabled);
-  await fsp.mkdir(path6.dirname(configPath), { recursive: true });
-  await fsp.writeFile(configPath, next, "utf8");
-  return next;
-}
-function isCodexFeatureEnabledFromConfig(content, featureName) {
-  const escaped = featureName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const featuresMatch = content.match(/^[^\S\r\n]*\[features\][^\S\r\n]*$/m);
-  if (!featuresMatch || featuresMatch.index === void 0) {
-    return false;
-  }
-  const sectionStart = featuresMatch.index + featuresMatch[0].length;
-  const nextSectionMatch = content.slice(sectionStart).match(/^[^\S\r\n]*\[[^\]\r\n]+\][^\S\r\n]*$/m);
-  const sectionEnd = nextSectionMatch && nextSectionMatch.index !== void 0 ? sectionStart + nextSectionMatch.index : content.length;
-  const featuresBody = content.slice(sectionStart, sectionEnd);
-  return new RegExp(`^\\s*${escaped}\\s*=\\s*true\\s*(?:#.*)?$`, "m").test(featuresBody);
-}
-async function readCodexFeatureFlag(codexHome, featureName) {
-  try {
-    const content = await fsp.readFile(resolveCodexConfigPath(codexHome), "utf8");
-    return isCodexFeatureEnabledFromConfig(content, featureName);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-function upsertCodexFeatureFlag(content, featureName, enabled) {
-  const normalized = content.replace(/\r\n/g, "\n");
-  const escaped = featureName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const featuresMatch = normalized.match(/^[^\S\r\n]*\[features\][^\S\r\n]*$/m);
-  const nextLine = `${featureName} = ${enabled ? "true" : "false"}`;
-  if (!featuresMatch || featuresMatch.index === void 0) {
-    const prefix = normalized.trimEnd();
-    return prefix ? `${prefix}
-
-[features]
-${nextLine}
-` : `[features]
-${nextLine}
-`;
-  }
-  const sectionStart = featuresMatch.index + featuresMatch[0].length;
-  const nextSectionMatch = normalized.slice(sectionStart).match(/^[^\S\r\n]*\[[^\]\r\n]+\][^\S\r\n]*$/m);
-  const sectionEnd = nextSectionMatch && nextSectionMatch.index !== void 0 ? sectionStart + nextSectionMatch.index : normalized.length;
-  const beforeSectionBody = normalized.slice(0, sectionStart);
-  const sectionBody = normalized.slice(sectionStart, sectionEnd);
-  const afterSection = normalized.slice(sectionEnd);
-  const flagPattern = new RegExp(
-    `(^[^\\S\\r\\n]*)${escaped}[^\\S\\r\\n]*=[^\\S\\r\\n]*(true|false)[^\\S\\r\\n]*(?:#.*)?$`,
-    "m"
-  );
-  if (flagPattern.test(sectionBody)) {
-    return beforeSectionBody + sectionBody.replace(flagPattern, `$1${nextLine}`) + afterSection;
-  }
-  const bodyWithFlag = `${sectionBody.replace(/\n*$/, "")}
-${nextLine}
-`;
-  const normalizedAfterSection = afterSection.startsWith("\n") ? afterSection : `
-${afterSection}`;
-  return beforeSectionBody + bodyWithFlag + normalizedAfterSection;
-}
-async function writeCodexFeatureFlag(codexHome, featureName, enabled) {
-  const configPath = resolveCodexConfigPath(codexHome);
-  let current = "";
-  try {
-    current = await fsp.readFile(configPath, "utf8");
-  } catch (error) {
-    if (error.code !== "ENOENT") {
-      throw error;
-    }
-  }
-  const next = upsertCodexFeatureFlag(current, featureName, enabled);
-  await fsp.mkdir(path6.dirname(configPath), { recursive: true });
-  await fsp.writeFile(configPath, next, "utf8");
-  return next;
-}
-
-// src/codex/runtime-errors.ts
-function unwrapCodexJsonRpcError(error) {
-  if (error instanceof JsonRpcClientError) {
-    return error;
-  }
-  if (error instanceof AgentRuntimeError && error.provider === "codex") {
-    return error.cause instanceof JsonRpcClientError ? error.cause : null;
-  }
-  return null;
-}
-function isCodexRemoteError(error) {
-  const codexError = unwrapCodexJsonRpcError(error);
-  return codexError?.code === "remote_error" ? codexError : null;
-}
-function isCodexRuntimeRequestError(error) {
-  return Boolean(unwrapCodexJsonRpcError(error));
-}
-function isRemoteThreadBootstrapError(error) {
-  const codexError = isCodexRemoteError(error);
-  if (!codexError) {
-    return false;
-  }
-  return codexError.message.includes("includeTurns is unavailable before first user message") || codexError.message.includes("is not materialized yet") || codexError.message.includes("no rollout found for thread id") || codexError.message.includes("failed to load rollout") || codexError.message.includes("rollout at") && codexError.message.includes("is empty");
-}
-function isUnsupportedHooksListError(error) {
-  const codexError = isCodexRemoteError(error);
-  if (!codexError) {
-    return false;
-  }
-  const remoteCode = codexError.details?.code;
-  const message = codexError.message.toLowerCase();
-  return remoteCode === -32601 || message.includes("endpoint not found") || message.includes("method not found") || message.includes("hooks/list") && message.includes("not found");
-}
-function parseTurnSteerRace(error) {
-  const codexError = isCodexRemoteError(error);
-  if (!codexError) {
-    return null;
-  }
-  if (codexError.message === "no active turn to steer") {
-    return { type: "missing" };
-  }
-  const mismatchPrefix = "expected active turn id `";
-  const mismatchSeparator = "` but found `";
-  if (!codexError.message.startsWith(mismatchPrefix)) {
-    return null;
-  }
-  const actualTurnId = codexError.message.slice(mismatchPrefix.length).split(mismatchSeparator)[1]?.replace(/`$/, "");
-  if (!actualTurnId) {
-    return null;
-  }
-  return {
-    type: "turnIdMismatch",
-    actualTurnId
-  };
-}
-
 // src/thread-history-items.ts
 var DEFERRED_COMMAND_DETAIL_TITLE2 = "Command Output";
 var DEFERRED_TOOL_DETAIL_TITLE2 = "Tool Call Details";
@@ -10298,7 +10711,7 @@ function deferLargeHistoryItemDetails(turn, deferredDetails) {
   };
 }
 function shouldPersistLiveHistoryItem(item) {
-  return item.kind === "commandExecution" || item.kind === "fileChange" || item.kind === "hook" || item.kind === "toolCall" || item.kind === "webSearch";
+  return item.kind === "agentMessage" || item.kind === "commandExecution" || item.kind === "fileChange" || item.kind === "hook" || item.kind === "toolCall" || item.kind === "webSearch";
 }
 function parseStoredHistoryItem(value) {
   try {
@@ -10333,14 +10746,59 @@ function sortTurnItemsByRecordedSequence(items) {
     leadingItems.push(items[index]);
     index += 1;
   }
-  return [...leadingItems, ...sortHistoryItemsBySequence(items.slice(index))];
+  const trailingItems = items.slice(index);
+  if (!trailingItems.some(hasHistoryItemSequence)) {
+    return items;
+  }
+  const sequenceValues = trailingItems.map((item) => historyItemSequence(item)).filter(Number.isFinite);
+  const maxSequence = sequenceValues.length > 0 ? Math.max(...sequenceValues) : 0;
+  const orderedItems = [];
+  let cursor = 0;
+  while (cursor < trailingItems.length) {
+    const item = trailingItems[cursor];
+    if (hasHistoryItemSequence(item)) {
+      orderedItems.push({ item, index: cursor, order: historyItemSequence(item) });
+      cursor += 1;
+      continue;
+    }
+    const blockStart = cursor;
+    while (cursor < trailingItems.length && !hasHistoryItemSequence(trailingItems[cursor])) {
+      cursor += 1;
+    }
+    const block = trailingItems.slice(blockStart, cursor);
+    const previousSequenced = [...trailingItems.slice(0, blockStart)].reverse().find(hasHistoryItemSequence);
+    const nextSequenced = trailingItems.slice(cursor).find(hasHistoryItemSequence);
+    const previousSequence = previousSequenced ? historyItemSequence(previousSequenced) : null;
+    const nextSequence = nextSequenced ? historyItemSequence(nextSequenced) : null;
+    block.forEach((blockItem, blockIndex) => {
+      let order;
+      if (previousSequence === null && nextSequence !== null) {
+        order = nextSequence - (block.length - blockIndex) / (block.length + 1);
+      } else if (previousSequence !== null && nextSequence !== null && nextSequence > previousSequence) {
+        const span = nextSequence - previousSequence;
+        order = previousSequence + (blockIndex + 1) / (block.length + 1) * span;
+      } else {
+        order = maxSequence + 1 + blockIndex / (block.length + 1);
+      }
+      orderedItems.push({
+        item: blockItem,
+        index: blockStart + blockIndex,
+        order
+      });
+    });
+  }
+  const sortedTrailingItems = orderedItems.sort((left, right) => {
+    const orderDelta = left.order - right.order;
+    return orderDelta === 0 ? left.index - right.index : orderDelta;
+  }).map((entry) => entry.item);
+  return [...leadingItems, ...sortedTrailingItems];
 }
 function mergeHistoryItemsBySequence(items, missingItems) {
   if (missingItems.length === 0) {
-    return items;
+    return sortTurnItemsByRecordedSequence(items);
   }
   if (!missingItems.some(hasHistoryItemSequence)) {
-    return [...items, ...missingItems];
+    return sortTurnItemsByRecordedSequence([...items, ...missingItems]);
   }
   const mergedItems = [...items];
   const orderedMissingItems = sortHistoryItemsBySequence(missingItems);
@@ -10365,16 +10823,20 @@ function mergeHistoryItemsBySequence(items, missingItems) {
     }
     mergedItems.push(missingItem);
   }
-  return mergedItems;
+  return sortTurnItemsByRecordedSequence(mergedItems);
+}
+function copyPersistedSequence(item, persistedItem) {
+  if (!hasHistoryItemSequence(persistedItem)) {
+    return item;
+  }
+  const sequence = historyItemSequence(persistedItem);
+  return item.sequence === sequence ? item : { ...item, sequence };
 }
 function mergePersistedHistoryItemsIntoTurns(turns, persistedItemsByTurnId, deferredDetails) {
   if (persistedItemsByTurnId.size === 0) {
     return turns;
   }
   return turns.map((turn) => {
-    if (turn.status === "inProgress") {
-      return turn;
-    }
     const persistedItems = persistedItemsByTurnId.get(turn.id);
     if (!persistedItems || persistedItems.length === 0) {
       return turn;
@@ -10383,23 +10845,32 @@ function mergePersistedHistoryItemsIntoTurns(turns, persistedItemsByTurnId, defe
     const persistedItemsById = new Map(persistedItems.map((item) => [item.id, item]));
     const nextItems = turn.items.map((item) => {
       const persistedItem = persistedItemsById.get(item.id);
-      if (!persistedItem || item.kind !== persistedItem.kind || persistedItem.kind !== "commandExecution" && persistedItem.kind !== "toolCall") {
+      if (!persistedItem) {
         return item;
       }
-      const existingText = item.detailText?.trim() || item.text.trim();
-      const persistedText = persistedItem.detailText?.trim() || persistedItem.text.trim();
-      if (persistedText.length <= existingText.length) {
+      persistedItemsById.delete(item.id);
+      if (item.kind !== persistedItem.kind) {
         return item;
       }
-      changed = true;
-      persistedItemsById.delete(item.id);
-      return persistedItem.kind === "commandExecution" ? deferCommandHistoryItem2(
-        persistedItem,
-        deferredDetails
-      ) : deferToolCallHistoryItem2(
-        persistedItem,
-        deferredDetails
-      );
+      const sequencedItem = copyPersistedSequence(item, persistedItem);
+      if (sequencedItem !== item) {
+        changed = true;
+      }
+      if (persistedItem.kind === "commandExecution" || persistedItem.kind === "toolCall") {
+        const existingText = item.detailText?.trim() || item.text.trim();
+        const persistedText = persistedItem.detailText?.trim() || persistedItem.text.trim();
+        if (persistedText.length > existingText.length) {
+          changed = true;
+          return persistedItem.kind === "commandExecution" ? deferCommandHistoryItem2(
+            persistedItem,
+            deferredDetails
+          ) : deferToolCallHistoryItem2(
+            persistedItem,
+            deferredDetails
+          );
+        }
+      }
+      return sequencedItem;
     });
     const existingItemIds = new Set(nextItems.map((item) => item.id));
     const missingItems = [...persistedItemsById.values()].filter((item) => !existingItemIds.has(item.id)).map(
@@ -10457,25 +10928,25 @@ function applyRecordedTurnItemOrders(turns, turnItemOrder) {
 }
 
 // src/codex/modelPricing.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs8 from "fs";
+import path8 from "path";
 var TOKEN_PRICE_DENOMINATOR = 1e6;
 var cachedPricingConfig = null;
 function resolvePackageRoot2(start = process.cwd()) {
   if (process.env.REMOTE_CODEX_PACKAGE_ROOT) {
-    return path7.resolve(process.env.REMOTE_CODEX_PACKAGE_ROOT);
+    return path8.resolve(process.env.REMOTE_CODEX_PACKAGE_ROOT);
   }
-  let current = path7.resolve(start);
-  while (current !== path7.dirname(current)) {
-    if (fs7.existsSync(path7.join(current, "pnpm-workspace.yaml"))) {
+  let current = path8.resolve(start);
+  while (current !== path8.dirname(current)) {
+    if (fs8.existsSync(path8.join(current, "pnpm-workspace.yaml"))) {
       return current;
     }
-    current = path7.dirname(current);
+    current = path8.dirname(current);
   }
   throw new Error("Unable to locate package root for Codex pricing config.");
 }
 function getPricingConfigPath() {
-  return path7.join(resolvePackageRoot2(), "config", "codex-model-pricing.json");
+  return path8.join(resolvePackageRoot2(), "config", "codex-model-pricing.json");
 }
 function isPositiveNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -10552,7 +11023,7 @@ function getPricingConfig() {
     return cachedPricingConfig;
   }
   const configPath = getPricingConfigPath();
-  const content = fs7.readFileSync(configPath, "utf8");
+  const content = fs8.readFileSync(configPath, "utf8");
   cachedPricingConfig = parsePricingConfig(JSON.parse(content));
   return cachedPricingConfig;
 }
@@ -10633,20 +11104,6 @@ var THREAD_DETAIL_CACHE_TTL_MS = 5e3;
 var CONTEXT_BASELINE_TOKENS = 12e3;
 var FAST_MODE_NOTE_ON = "Fast mode on";
 var FAST_MODE_NOTE_OFF = "Fast mode off";
-var HOOK_EVENT_JSON_KEYS = {
-  preToolUse: "PreToolUse",
-  permissionRequest: "PermissionRequest",
-  postToolUse: "PostToolUse",
-  preCompact: "PreCompact",
-  postCompact: "PostCompact",
-  sessionStart: "SessionStart",
-  userPromptSubmit: "UserPromptSubmit",
-  stop: "Stop"
-};
-var HOOK_EVENT_DTO_KEYS = Object.fromEntries(
-  Object.entries(HOOK_EVENT_JSON_KEYS).map(([dtoKey, jsonKey]) => [jsonKey, dtoKey])
-);
-var GOAL_FEATURE_DISABLED_MESSAGE = "Codex /goal is experimental. Enable it by adding `goals = true` under `[features]` in ~/.codex/config.toml, then restart the Codex app-server.";
 function toIsoFromEpoch2(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) {
     return (/* @__PURE__ */ new Date()).toISOString();
@@ -10718,22 +11175,36 @@ function mergeGoalHistoryEntry(existing, incoming) {
     localGoalId: latest.localGoalId ?? fallback.localGoalId ?? null
   };
 }
-function mapCodexGoalError(error) {
-  const codexError = unwrapCodexJsonRpcError(error);
-  if (codexError) {
-    const remoteMessage = codexError.message || "";
-    if (remoteMessage.toLowerCase().includes("goals feature is disabled")) {
-      throw new HttpError(409, {
-        code: "goal_feature_disabled",
-        message: GOAL_FEATURE_DISABLED_MESSAGE
-      });
-    }
-    throw new HttpError(502, {
-      code: "codex_goal_error",
-      message: remoteMessage || "Codex goal operation failed."
-    });
+function goalHistoryStatusRank(status) {
+  return ["active", "paused", "budgetLimited"].includes(status) ? 0 : 1;
+}
+function resetGoalProgress(goal) {
+  return {
+    ...goal,
+    tokensUsed: 0,
+    timeUsedSeconds: 0
+  };
+}
+function goalObjectiveChanged(existing, nextObjective) {
+  return existing !== null && typeof nextObjective === "string" && nextObjective.trim().length > 0 && nextObjective !== existing.objective;
+}
+function isLocalGoalStatus(status) {
+  return ["active", "paused", "budgetLimited"].includes(status);
+}
+function localGoalSnapshotForFallback(goalHistory) {
+  const activeGoal = goalHistory.find((entry) => isLocalGoalStatus(entry.status)) ?? null;
+  if (activeGoal) {
+    return activeGoal;
+  }
+  return goalHistory.find((entry) => entry.status === "terminated") ?? null;
+}
+function localGoalSnapshotToPreserve(goalHistory, remoteGoal) {
+  const activeGoal = goalHistory.find((entry) => isLocalGoalStatus(entry.status)) ?? null;
+  const hasTerminatedHistory = goalHistory.some((entry) => entry.status === "terminated");
+  if (activeGoal && hasTerminatedHistory && isLocalGoalStatus(remoteGoal.status) && activeGoal.objective === remoteGoal.objective && activeGoal.tokensUsed === 0 && activeGoal.timeUsedSeconds === 0 && (remoteGoal.tokensUsed > 0 || remoteGoal.timeUsedSeconds > 0)) {
+    return activeGoal;
   }
-  throw error;
+  return activeGoal ? null : goalHistory.find((entry) => entry.status === "terminated") ?? null;
 }
 function defaultSandboxModeForApprovalMode(approvalMode) {
   return approvalMode === "guarded" ? "workspace-write" : "danger-full-access";
@@ -10748,34 +11219,6 @@ function normalizeSandboxMode(value) {
       return null;
   }
 }
-function buildTurnSandboxPolicy(sandboxMode, writableRoot) {
-  switch (sandboxMode) {
-    case "danger-full-access":
-      return {
-        type: "dangerFullAccess"
-      };
-    case "read-only":
-      return {
-        type: "readOnly",
-        access: {
-          type: "fullAccess"
-        },
-        networkAccess: false
-      };
-    case "workspace-write":
-    default:
-      return {
-        type: "workspaceWrite",
-        writableRoots: [writableRoot],
-        readOnlyAccess: {
-          type: "fullAccess"
-        },
-        networkAccess: false,
-        excludeTmpdirEnvVar: false,
-        excludeSlashTmp: false
-      };
-  }
-}
 function normalizeReasoningEffort(value) {
   switch (value) {
     case "none":
@@ -10795,8 +11238,8 @@ function normalizeCollaborationMode(value) {
 function normalizeFastMode(value) {
   return value === true || value === 1;
 }
-function serviceTierForFastMode(fastMode) {
-  return fastMode ? "fast" : null;
+function performanceModeForFastMode(fastMode) {
+  return fastMode ? "fast" : "standard";
 }
 function normalizePricingTier(value) {
   return value === "fast" || value === "standard" ? value : null;
@@ -10841,26 +11284,26 @@ function buildAnsweredRequestNote(request, input) {
 }
 async function pathExists(absPath) {
   try {
-    await fs8.access(absPath);
+    await fs9.access(absPath);
     return true;
   } catch {
     return false;
   }
 }
 async function resolveComparablePath2(absPath) {
-  const resolved = path8.resolve(absPath);
+  const resolved = path9.resolve(absPath);
   if (await pathExists(resolved)) {
-    return fs8.realpath(resolved);
+    return fs9.realpath(resolved);
   }
-  const parentPath = path8.dirname(resolved);
+  const parentPath = path9.dirname(resolved);
   if (parentPath === resolved) {
     return resolved;
   }
   const resolvedParent = await resolveComparablePath2(parentPath);
-  return path8.join(resolvedParent, path8.basename(resolved));
+  return path9.join(resolvedParent, path9.basename(resolved));
 }
 async function resolveImportedWorkspacePath(workspaceRoot, candidatePath) {
-  if (!path8.isAbsolute(candidatePath)) {
+  if (!path9.isAbsolute(candidatePath)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Imported session path must be absolute."
@@ -10868,7 +11311,7 @@ async function resolveImportedWorkspacePath(workspaceRoot, candidatePath) {
   }
   const resolvedRoot = await resolveComparablePath2(workspaceRoot);
   const resolvedCandidate = await resolveComparablePath2(candidatePath);
-  const normalizedRoot = resolvedRoot.endsWith(path8.sep) ? resolvedRoot : `${resolvedRoot}${path8.sep}`;
+  const normalizedRoot = resolvedRoot.endsWith(path9.sep) ? resolvedRoot : `${resolvedRoot}${path9.sep}`;
   if (resolvedCandidate !== resolvedRoot && !resolvedCandidate.startsWith(normalizedRoot)) {
     throw new HttpError(403, {
       code: "forbidden",
@@ -10888,7 +11331,7 @@ function toWorkspaceDto(record) {
     lastOpenedAt: record.lastOpenedAt
   };
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function numberOrNull2(value) {
@@ -10927,11 +11370,11 @@ function computeContextRemainingPercent(tokensInContextWindow, contextWindow) {
   return clampPercentage(Math.round(remaining / effectiveWindow * 100));
 }
 function buildThreadContextUsageFromPayload(payload, model = null, timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
-  const tokenUsage = isRecord4(payload) ? payload : null;
+  const tokenUsage = isRecord5(payload) ? payload : null;
   const modelContextWindow = contextWindowForModel(model) ?? numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
   );
-  const lastUsage = isRecord4(tokenUsage?.last) ? tokenUsage.last : null;
+  const lastUsage = isRecord5(tokenUsage?.last) ? tokenUsage.last : null;
   const tokensInContextWindow = numberOrNull2(
     lastUsage?.totalTokens ?? lastUsage?.total_tokens
   );
@@ -10950,7 +11393,7 @@ function buildThreadContextUsageFromPayload(payload, model = null, timestamp = (
   };
 }
 function buildTurnTokenBreakdown(payload) {
-  const usage = isRecord4(payload) ? payload : null;
+  const usage = isRecord5(payload) ? payload : null;
   const totalTokens2 = numberOrNull2(usage?.totalTokens ?? usage?.total_tokens);
   const inputTokens = numberOrNull2(usage?.inputTokens ?? usage?.input_tokens);
   const cachedInputTokens = numberOrNull2(
@@ -10996,12 +11439,12 @@ function subtractTurnTokenBreakdowns(current, previous) {
   };
 }
 function parseThreadTurnTokenUsage(payload) {
-  const tokenUsage = isRecord4(payload) ? payload : null;
+  const tokenUsage = isRecord5(payload) ? payload : null;
   const total = buildTurnTokenBreakdown(
-    isRecord4(tokenUsage?.total) ? tokenUsage.total : null
+    isRecord5(tokenUsage?.total) ? tokenUsage.total : null
   );
   const last = buildTurnTokenBreakdown(
-    isRecord4(tokenUsage?.last) ? tokenUsage.last : null
+    isRecord5(tokenUsage?.last) ? tokenUsage.last : null
   );
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
@@ -11025,7 +11468,7 @@ function parseStoredThreadTurnTokenUsageState(value) {
   try {
     const parsed = JSON.parse(value);
     const baselineTotal = buildTurnTokenBreakdown(
-      isRecord4(parsed?.baselineTotal) ? parsed.baselineTotal : null
+      isRecord5(parsed?.baselineTotal) ? parsed.baselineTotal : null
     );
     return {
       baselineTotal,
@@ -11062,12 +11505,12 @@ function stringifyStoredThreadTurnTokenUsageState(state) {
   });
 }
 function buildThreadTurnTokenUsage(payload, baselineTotal, previous = null) {
-  const tokenUsage = isRecord4(payload) ? payload : null;
+  const tokenUsage = isRecord5(payload) ? payload : null;
   const cumulativeTotal = buildTurnTokenBreakdown(
-    isRecord4(tokenUsage?.total) ? tokenUsage.total : null
+    isRecord5(tokenUsage?.total) ? tokenUsage.total : null
   );
   const last = buildTurnTokenBreakdown(
-    isRecord4(tokenUsage?.last) ? tokenUsage.last : null
+    isRecord5(tokenUsage?.last) ? tokenUsage.last : null
   );
   const modelContextWindow = numberOrNull2(
     tokenUsage?.modelContextWindow ?? tokenUsage?.model_context_window
@@ -11085,8 +11528,8 @@ function parseThreadTurnTokenUsageJson(value) {
   return parseStoredThreadTurnTokenUsageState(value).usage;
 }
 function sanitizeAttachmentFileName(originalName) {
-  const basename = path8.basename(originalName).trim() || "attachment";
-  const extension = path8.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
+  const basename = path9.basename(originalName).trim() || "attachment";
+  const extension = path9.extname(basename).replace(/[^a-zA-Z0-9.]/g, "");
   const rawStem = extension ? basename.slice(0, -extension.length) : basename;
   const sanitizedStem = rawStem.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 64);
   const stem = sanitizedStem || "attachment";
@@ -11094,269 +11537,7 @@ function sanitizeAttachmentFileName(originalName) {
   return `${stem}-${randomUUID2().slice(0, 8)}${normalizedExtension}`;
 }
 function threadTempDirectoryPath(workspacePath, localThreadId) {
-  return path8.join(workspacePath, ".temp", "threads", localThreadId);
-}
-function normalizeHooksJson(value) {
-  if (!isRecord4(value) || !isRecord4(value.hooks)) {
-    return { hooks: {} };
-  }
-  const hooks = {};
-  for (const [eventName, groups] of Object.entries(value.hooks)) {
-    hooks[eventName] = Array.isArray(groups) ? groups : [];
-  }
-  return { ...value, hooks };
-}
-function readJsonFileOrDefault(filePath) {
-  return fs8.readFile(filePath, "utf8").then((raw) => {
-    if (!raw.trim()) {
-      return { hooks: {} };
-    }
-    return normalizeHooksJson(JSON.parse(raw));
-  }).catch((error) => {
-    if (error.code === "ENOENT") {
-      return { hooks: {} };
-    }
-    throw error;
-  });
-}
-function validateHookInput(input) {
-  if (!HOOK_EVENT_JSON_KEYS[input.eventName]) {
-    throw new HttpError(400, {
-      code: "bad_request",
-      message: "Unsupported hook event."
-    });
-  }
-  if (input.scope !== "global" && input.scope !== "project") {
-    throw new HttpError(400, {
-      code: "bad_request",
-      message: "Hook scope must be global or project."
-    });
-  }
-  if (!input.command.trim()) {
-    throw new HttpError(400, {
-      code: "bad_request",
-      message: "Hook command cannot be empty."
-    });
-  }
-  if (input.timeoutSec !== void 0 && input.timeoutSec !== null && (!Number.isInteger(input.timeoutSec) || input.timeoutSec <= 0 || input.timeoutSec > 86400)) {
-    throw new HttpError(400, {
-      code: "bad_request",
-      message: "Hook timeout must be a positive number of seconds."
-    });
-  }
-}
-async function writeHookJsonEntry({
-  codexHome,
-  workspacePath,
-  input
-}) {
-  validateHookInput(input);
-  const hooksPath = input.scope === "global" ? path8.join(codexHome, "hooks.json") : path8.join(workspacePath, ".codex", "hooks.json");
-  const config = await readJsonFileOrDefault(hooksPath);
-  const eventKey = HOOK_EVENT_JSON_KEYS[input.eventName];
-  const matcher = input.matcher?.trim() || null;
-  const handler = {
-    type: "command",
-    command: input.command.trim()
-  };
-  if (input.timeoutSec !== void 0 && input.timeoutSec !== null) {
-    handler.timeout = input.timeoutSec;
-  }
-  if (input.statusMessage?.trim()) {
-    handler.statusMessage = input.statusMessage.trim();
-  }
-  const group = {
-    hooks: [handler]
-  };
-  if (matcher) {
-    group.matcher = matcher;
-  }
-  const currentGroups = Array.isArray(config.hooks[eventKey]) ? config.hooks[eventKey] : [];
-  config.hooks[eventKey] = [...currentGroups, group];
-  await fs8.mkdir(path8.dirname(hooksPath), { recursive: true });
-  await fs8.writeFile(hooksPath, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-}
-function hookInputMatches(group, handler, input) {
-  if (!isRecord4(group) || !isRecord4(handler)) {
-    return false;
-  }
-  const matcher = typeof group.matcher === "string" ? group.matcher : null;
-  const handlerCommand = typeof handler.command === "string" ? handler.command : "";
-  const handlerTimeout = typeof handler.timeout === "number" && Number.isFinite(handler.timeout) ? handler.timeout : null;
-  const handlerStatusMessage = typeof handler.statusMessage === "string" ? handler.statusMessage : null;
-  return handler.type === "command" && (input.matcher?.trim() || null) === matcher && input.command.trim() === handlerCommand && (input.timeoutSec ?? null) === handlerTimeout && (input.statusMessage?.trim() || null) === handlerStatusMessage;
-}
-async function updateHookJsonEntry({
-  codexHome,
-  workspacePath,
-  input
-}) {
-  validateHookInput(input);
-  validateHookInput(input.target);
-  if (input.scope !== input.target.scope) {
-    throw new HttpError(400, {
-      code: "bad_request",
-      message: "Hook scope cannot be changed while editing."
-    });
-  }
-  const hooksPath = input.scope === "global" ? path8.join(codexHome, "hooks.json") : path8.join(workspacePath, ".codex", "hooks.json");
-  const config = await readJsonFileOrDefault(hooksPath);
-  const targetEventKey = HOOK_EVENT_JSON_KEYS[input.target.eventName];
-  const nextEventKey = HOOK_EVENT_JSON_KEYS[input.eventName];
-  const currentGroups = Array.isArray(config.hooks[targetEventKey]) ? config.hooks[targetEventKey] : [];
-  let replacementGroup = null;
-  config.hooks[targetEventKey] = currentGroups.map((group) => {
-    if (replacementGroup || !isRecord4(group) || !Array.isArray(group.hooks)) {
-      return group;
-    }
-    const hookIndex = group.hooks.findIndex(
-      (handler2) => hookInputMatches(group, handler2, input.target)
-    );
-    if (hookIndex < 0) {
-      return group;
-    }
-    const handler = {
-      type: "command",
-      command: input.command.trim()
-    };
-    if (input.timeoutSec !== void 0 && input.timeoutSec !== null) {
-      handler.timeout = input.timeoutSec;
-    }
-    if (input.statusMessage?.trim()) {
-      handler.statusMessage = input.statusMessage.trim();
-    }
-    replacementGroup = {
-      hooks: [handler]
-    };
-    const matcher = input.matcher?.trim() || null;
-    if (matcher) {
-      replacementGroup.matcher = matcher;
-    }
-    if (targetEventKey !== nextEventKey) {
-      const remainingHooks = group.hooks.filter((_, index) => index !== hookIndex);
-      return {
-        ...group,
-        hooks: remainingHooks
-      };
-    }
-    return {
-      ...replacementGroup,
-      hooks: group.hooks.map(
-        (existing, index) => index === hookIndex ? replacementGroup.hooks[0] : existing
-      )
-    };
-  }).filter((group) => {
-    if (!isRecord4(group) || !Array.isArray(group.hooks)) {
-      return true;
-    }
-    return group.hooks.length > 0;
-  });
-  if (!replacementGroup) {
-    throw new HttpError(404, {
-      code: "not_found",
-      message: "Hook was not found in hooks.json."
-    });
-  }
-  if (targetEventKey !== nextEventKey) {
-    if (config.hooks[targetEventKey]?.length === 0) {
-      delete config.hooks[targetEventKey];
-    }
-    const nextGroups = Array.isArray(config.hooks[nextEventKey]) ? config.hooks[nextEventKey] : [];
-    config.hooks[nextEventKey] = [...nextGroups, replacementGroup];
-  }
-  await fs8.mkdir(path8.dirname(hooksPath), { recursive: true });
-  await fs8.writeFile(hooksPath, `${JSON.stringify(config, null, 2)}
-`, "utf8");
-}
-async function readLocalHookDtos({
-  hooksPath,
-  source,
-  displayOffset
-}) {
-  const config = await readJsonFileOrDefault(hooksPath);
-  const hooks = [];
-  for (const [eventKey, groups] of Object.entries(config.hooks)) {
-    const eventName = HOOK_EVENT_DTO_KEYS[eventKey];
-    if (!eventName || !Array.isArray(groups)) {
-      continue;
-    }
-    groups.forEach((group, groupIndex) => {
-      if (!isRecord4(group) || !Array.isArray(group.hooks)) {
-        return;
-      }
-      const matcher = typeof group.matcher === "string" ? group.matcher : null;
-      group.hooks.forEach((handler, handlerIndex) => {
-        if (!isRecord4(handler) || handler.type !== "command") {
-          return;
-        }
-        const command = typeof handler.command === "string" ? handler.command : null;
-        if (!command) {
-          return;
-        }
-        const timeoutSec = typeof handler.timeout === "number" && Number.isFinite(handler.timeout) ? handler.timeout : 600;
-        const statusMessage = typeof handler.statusMessage === "string" ? handler.statusMessage : null;
-        const key = `${source}:${hooksPath}:${eventKey}:${groupIndex}:${handlerIndex}`;
-        hooks.push({
-          key,
-          eventName,
-          handlerType: "command",
-          matcher,
-          command,
-          timeoutSec,
-          statusMessage,
-          sourcePath: hooksPath,
-          source,
-          pluginId: null,
-          displayOrder: displayOffset + hooks.length,
-          enabled: true,
-          isManaged: false,
-          currentHash: "",
-          trustStatus: "untrusted"
-        });
-      });
-    });
-  }
-  return hooks;
-}
-function hookMatchesInput(hook, input) {
-  return hook.source === input.scope && hook.eventName === input.eventName && (hook.matcher ?? null) === (input.matcher ?? null) && hook.command === input.command && (input.timeoutSec == null || hook.timeoutSec === input.timeoutSec) && (hook.statusMessage ?? null) === (input.statusMessage ?? null);
-}
-async function findOfficialHookForInput(runtime, workspacePath, input) {
-  if (!runtime.listHooks) {
-    return null;
-  }
-  const [entry] = await runtime.listHooks({
-    cwds: [workspacePath]
-  });
-  const officialHooks = (entry?.hooks ?? []).map((hook) => ({
-    key: hook.key,
-    eventName: hook.eventName,
-    handlerType: hook.handlerType,
-    matcher: hook.matcher,
-    command: hook.command,
-    timeoutSec: hook.timeoutSec,
-    statusMessage: hook.statusMessage,
-    sourcePath: hook.sourcePath,
-    source: hook.source,
-    pluginId: hook.pluginId,
-    displayOrder: hook.displayOrder,
-    enabled: hook.enabled,
-    isManaged: hook.isManaged,
-    currentHash: hook.currentHash,
-    trustStatus: hook.trustStatus
-  }));
-  return officialHooks.find((hook) => hookMatchesInput(hook, input)) ?? null;
-}
-async function trustHookForInput(runtime, workspacePath, input) {
-  const hook = await findOfficialHookForInput(runtime, workspacePath, input);
-  if (!runtime.setHookTrust || !hook || !hook.key || !hook.currentHash || hook.isManaged) {
-    return;
-  }
-  await runtime.setHookTrust({
-    key: hook.key,
-    trustedHash: hook.currentHash
-  });
+  return path9.join(workspacePath, ".temp", "threads", localThreadId);
 }
 function buildTurnDto(turn, metadata) {
   const tokenUsage = parseThreadTurnTokenUsageJson(metadata?.tokenUsageJson);
@@ -11416,13 +11597,13 @@ function safeTranscriptExportFileName(title, extension) {
   return `remote-codex-${stem || "thread"}-${timestamp}.${extension}`;
 }
 var ThreadService = class {
-  constructor(db, agentRuntimes, eventBus, localSessionStore, workspaceRoot, codexHome) {
+  constructor(db, agentRuntimes, eventBus, localSessionStore, workspaceRoot, codexManagement) {
     this.db = db;
     this.agentRuntimes = agentRuntimes;
     this.eventBus = eventBus;
     this.localSessionStore = localSessionStore;
     this.workspaceRoot = workspaceRoot;
-    this.codexHome = codexHome;
+    this.codexManagement = codexManagement;
     for (const runtime of this.agentRuntimes.all()) {
       runtime.on("event", (event) => {
         void this.handleRuntimeEvent(event);
@@ -11437,7 +11618,7 @@ var ThreadService = class {
   eventBus;
   localSessionStore;
   workspaceRoot;
-  codexHome;
+  codexManagement;
   pendingRequests = /* @__PURE__ */ new Map();
   dismissedPlanDecisionTurns = /* @__PURE__ */ new Map();
   threadDetailCache = /* @__PURE__ */ new Map();
@@ -11497,13 +11678,13 @@ var ThreadService = class {
     return this.providerForRecord({ provider }) === "codex";
   }
   runtimeSupportsFastMode(provider) {
-    return this.runtimeForProvider(provider).capabilities.controls.fastServiceTier;
+    return this.runtimeForProvider(provider).capabilities.controls.performanceMode;
   }
   fastModeForProvider(provider, fastMode) {
     return this.runtimeSupportsFastMode(provider) ? normalizeFastMode(fastMode) : false;
   }
-  serviceTierForRecord(record) {
-    return serviceTierForFastMode(this.fastModeForProvider(record.provider, record.fastMode));
+  performanceModeForRecord(record) {
+    return performanceModeForFastMode(this.fastModeForProvider(record.provider, record.fastMode));
   }
   assertCodexHooksFileManagement(provider) {
     if (!this.isCodexProvider(provider)) {
@@ -11740,7 +11921,7 @@ var ThreadService = class {
     const matchedModel = modelRecords.find((entry) => entry.model === input.model);
     const reasoningEffort = normalizeReasoningEffort(matchedModel?.defaultReasoningEffort) ?? "medium";
     const sandboxMode = defaultSandboxModeForApprovalMode(input.approvalMode);
-    const fastMode = this.runtimeSupportsFastMode(provider) ? readCodexFastModeSync(this.codexHome) : false;
+    const fastMode = this.runtimeSupportsFastMode(provider) ? this.codexManagement.readFastMode() : false;
     if (this.runtimeSupportsFastMode(provider)) {
       ensureFastModeSupported(input.model, fastMode);
     }
@@ -11749,7 +11930,7 @@ var ThreadService = class {
       model: input.model,
       approvalMode: input.approvalMode,
       sandboxMode,
-      serviceTier: serviceTierForFastMode(fastMode)
+      performanceMode: performanceModeForFastMode(fastMode)
     });
     const created = createThreadRecord(this.db, {
       workspaceId: workspace.id,
@@ -11804,7 +11985,7 @@ var ThreadService = class {
     if (!workspace) {
       workspace = createWorkspaceRecord(this.db, {
         absPath: importedPath,
-        label: path8.basename(importedPath) || "workspace"
+        label: path9.basename(importedPath) || "workspace"
       });
     }
     const created = createThreadRecord(this.db, {
@@ -11820,7 +12001,7 @@ var ThreadService = class {
       approvalMode: "yolo",
       sandboxMode: defaultSandboxModeForApprovalMode("yolo"),
       summaryText: localSession.turns.flatMap((turn) => turn.items).find((item) => item.kind === "userMessage")?.text ?? null,
-      fastMode: readCodexFastModeSync(this.codexHome),
+      fastMode: this.codexManagement.readFastMode(),
       source: "local_codex_import",
       isConnected: false
     });
@@ -11869,8 +12050,8 @@ var ThreadService = class {
       cachedDetail.turns,
       pagedTurns.turns
     );
-    const goal = await this.getThreadGoalForRecord(updated).catch(() => null);
     const goalHistory = this.listThreadGoalHistory(updated.id);
+    const goal = await this.getThreadGoalForRecord(updated).catch(() => null) ?? localGoalSnapshotForFallback(goalHistory);
     return {
       thread: this.toThreadDto(updated, loadedIds),
       workspace: toWorkspaceDto(workspace),
@@ -12010,7 +12191,7 @@ var ThreadService = class {
       });
     }
     this.requireProviderSessionId(record);
-    return this.getThreadGoalForRecord(record, { allowEnableFeature: true });
+    return await this.getThreadGoalForRecord(record, { allowEnableFeature: true }) ?? localGoalSnapshotForFallback(this.listThreadGoalHistory(localThreadId));
   }
   async updateThreadGoal(localThreadId, input) {
     const record = getThreadRecordById(this.db, localThreadId);
@@ -12037,14 +12218,32 @@ var ThreadService = class {
     try {
       await this.ensureGoalsFeatureEnabled(record.provider);
       await this.ensureThreadLoadedForCodexOperation(record);
-      const upstreamStatus = input.status === "terminated" ? void 0 : input.status;
+      const activeGoal = this.listThreadGoalHistory(localThreadId).find(
+        (goal2) => ["active", "paused", "budgetLimited"].includes(goal2.status)
+      ) ?? null;
+      const creatingNewGoal = goalObjectiveChanged(activeGoal, input.objective);
+      if (creatingNewGoal) {
+        markActiveThreadGoalRecordTerminated(this.db, localThreadId);
+      }
+      if (input.status === "terminated") {
+        const terminatedGoal = markActiveThreadGoalRecordTerminated(this.db, localThreadId);
+        const goalHistory = this.listThreadGoalHistory(localThreadId);
+        const goal2 = terminatedGoal ? toThreadGoalDtoFromRecord(terminatedGoal) : goalHistory[0] ?? null;
+        this.emitThreadEvent("thread.goal.updated", localThreadId, {
+          goal: goal2,
+          goalHistory
+        });
+        return goal2;
+      }
+      const upstreamStatus = input.status;
       const goal = await runtime.setGoal({
         providerSessionId,
         ...input.objective !== void 0 ? { objective: input.objective } : {},
         ...upstreamStatus !== void 0 ? { status: upstreamStatus } : {},
         ...input.tokenBudget !== void 0 ? { tokenBudget: input.tokenBudget } : {}
       });
-      const dto = normalizeThreadGoalStatusForThread(toThreadGoalDtoFromAgentGoal(goal), record);
+      const upstreamDto = normalizeThreadGoalStatusForThread(toThreadGoalDtoFromAgentGoal(goal), record);
+      const dto = creatingNewGoal ? resetGoalProgress(upstreamDto) : upstreamDto;
       const persistedGoal = toThreadGoalDtoFromRecord(
         this.persistThreadGoalSnapshot(localThreadId, dto)
       );
@@ -12054,7 +12253,7 @@ var ThreadService = class {
       });
       return persistedGoal;
     } catch (error) {
-      mapCodexGoalError(error);
+      this.codexManagement.mapGoalError(error);
     }
   }
   async clearThreadGoal(localThreadId) {
@@ -12088,7 +12287,7 @@ var ThreadService = class {
       this.emitThreadEvent("thread.goal.cleared", localThreadId, { goalHistory });
       return { cleared, goalHistory };
     } catch (error) {
-      mapCodexGoalError(error);
+      this.codexManagement.mapGoalError(error);
     }
   }
   async getThreadGoalForRecord(record, options = {}) {
@@ -12109,9 +12308,16 @@ var ThreadService = class {
         return null;
       }
       const dto = normalizeThreadGoalStatusForThread(toThreadGoalDtoFromAgentGoal(goal), record);
+      const localGoal = localGoalSnapshotToPreserve(
+        this.listThreadGoalHistory(record.id),
+        dto
+      );
+      if (localGoal) {
+        return localGoal;
+      }
       return toThreadGoalDtoFromRecord(this.persistThreadGoalSnapshot(record.id, dto));
     } catch (error) {
-      if (isCodexRuntimeRequestError(error)) {
+      if (this.codexManagement.isRuntimeRequestError(error)) {
         return null;
       }
       throw error;
@@ -12144,29 +12350,20 @@ var ThreadService = class {
       deduped.set(key, existing ? mergeGoalHistoryEntry(existing, goal) : goal);
     }
     return [...deduped.values()].sort(
-      (left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)
+      (left, right) => {
+        const updatedDelta = Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
+        if (updatedDelta !== 0) {
+          return updatedDelta;
+        }
+        return goalHistoryStatusRank(left.status) - goalHistoryStatusRank(right.status);
+      }
     );
   }
   async ensureGoalsFeatureEnabled(provider) {
     if (!this.isCodexProvider(provider)) {
       return;
     }
-    try {
-      if (await readCodexFeatureFlag(this.codexHome, "goals")) {
-        return;
-      }
-      await writeCodexFeatureFlag(this.codexHome, "goals", true);
-      await this.codexRuntime().stop();
-      await this.codexRuntime().start();
-    } catch (error) {
-      if (isCodexRuntimeRequestError(error)) {
-        throw new HttpError(409, {
-          code: "goal_feature_disabled",
-          message: GOAL_FEATURE_DISABLED_MESSAGE
-        });
-      }
-      throw error;
-    }
+    await this.codexManagement.ensureGoalsFeatureEnabled(this.codexRuntime());
   }
   async ensureThreadLoadedForCodexOperation(record) {
     if (!record.providerSessionId) {
@@ -12244,7 +12441,7 @@ var ThreadService = class {
       });
     }
     const tempDirectory = threadTempDirectoryPath(workspace.absPath, localThreadId);
-    await fs8.mkdir(tempDirectory, { recursive: true });
+    await fs9.mkdir(tempDirectory, { recursive: true });
     let rewrittenPrompt = input.prompt;
     for (const attachment of attachments) {
       if (!rewrittenPrompt.includes(attachment.manifest.placeholder)) {
@@ -12254,7 +12451,7 @@ var ThreadService = class {
         });
       }
       const savedFileName = sanitizeAttachmentFileName(attachment.manifest.originalName);
-      await fs8.writeFile(path8.join(tempDirectory, savedFileName), attachment.buffer);
+      await fs9.writeFile(path9.join(tempDirectory, savedFileName), attachment.buffer);
       const relativePath = `./.temp/threads/${localThreadId}/${savedFileName}`;
       const replacementToken = attachment.manifest.kind === "photo" ? `[PHOTO ${relativePath}]` : `[FILE ${relativePath}]`;
       rewrittenPrompt = rewrittenPrompt.split(attachment.manifest.placeholder).join(replacementToken);
@@ -12286,7 +12483,7 @@ var ThreadService = class {
         providerSessionId,
         model: input.model ?? record.model ?? null,
         sandboxMode,
-        serviceTier: serviceTierForFastMode(fastMode)
+        performanceMode: performanceModeForFastMode(fastMode)
       });
     } catch (error) {
       if (!isRemoteThreadBootstrapError(error)) {
@@ -12391,7 +12588,7 @@ var ThreadService = class {
     const sandboxMode = (input.sandboxMode !== void 0 ? normalizeSandboxMode(input.sandboxMode) : normalizeSandboxMode(record.sandboxMode)) ?? defaultSandboxModeForApprovalMode(record.approvalMode ?? "yolo");
     const fastMode = this.fastModeForProvider(record.provider, record.fastMode);
     ensureFastModeSupported(effectiveModel, fastMode);
-    const serviceTier = serviceTierForFastMode(fastMode);
+    const performanceMode = performanceModeForFastMode(fastMode);
     const connectedRecord = {
       ...record,
       providerSessionId
@@ -12408,7 +12605,7 @@ var ThreadService = class {
         normalizedReasoning,
         collaborationMode,
         sandboxMode,
-        serviceTier,
+        performanceMode,
         workspacePath: workspace.absPath
       });
     }
@@ -12418,26 +12615,27 @@ var ThreadService = class {
       normalizedReasoning,
       collaborationMode,
       sandboxMode,
-      serviceTier,
+      performanceMode,
       workspacePath: workspace.absPath
     });
   }
   async startPromptTurn(localThreadId, record, input) {
     const runtime = this.runtimeForProvider(record.provider);
     const modelRecords = await runtime.listModels().catch(() => []);
-    ensureFastModeSupported(input.effectiveModel, input.serviceTier === "fast");
+    ensureFastModeSupported(input.effectiveModel, input.performanceMode === "fast");
     const pricingSnapshot = buildTurnPricingSnapshot(
       input.effectiveModel,
-      input.serviceTier === "fast"
+      input.performanceMode === "fast"
     );
     const turn = await runtime.startTurn({
       providerSessionId: record.providerSessionId,
       prompt: input.prompt,
       model: input.effectiveModel,
-      serviceTier: input.serviceTier,
+      performanceMode: input.performanceMode,
       reasoningEffort: input.normalizedReasoning,
       collaborationMode: input.collaborationMode,
-      sandboxPolicy: buildTurnSandboxPolicy(input.sandboxMode, input.workspacePath)
+      sandboxMode: input.sandboxMode,
+      workspacePath: input.workspacePath
     });
     upsertThreadTurnMetadata(this.db, {
       threadId: localThreadId,
@@ -12525,7 +12723,7 @@ var ThreadService = class {
       normalizedReasoning: input.normalizedReasoning,
       collaborationMode: input.collaborationMode,
       sandboxMode: input.sandboxMode,
-      serviceTier: input.serviceTier,
+      performanceMode: input.performanceMode,
       workspacePath: input.workspacePath
     });
   }
@@ -12559,7 +12757,7 @@ var ThreadService = class {
       this.clearPendingPlanDecisionRequests(localThreadId, true);
     }
     if (supportsFastMode2 && currentFastMode !== nextFastMode) {
-      await writeCodexFastMode(this.codexHome, nextFastMode);
+      await this.codexManagement.writeFastMode(nextFastMode);
       this.appendActivityNote(localThreadId, {
         kind: "fastMode",
         text: nextFastMode ? FAST_MODE_NOTE_ON : FAST_MODE_NOTE_OFF
@@ -12912,12 +13110,7 @@ var ThreadService = class {
       });
     }
     this.assertCodexHooksFileManagement(record.provider);
-    await writeHookJsonEntry({
-      codexHome: this.codexHome,
-      workspacePath: workspace.absPath,
-      input
-    });
-    await trustHookForInput(runtime, workspace.absPath, input);
+    await this.codexManagement.writeHookEntry(runtime, workspace.absPath, input);
     return this.listThreadHooks(localThreadId);
   }
   async updateThreadHook(localThreadId, input) {
@@ -12943,12 +13136,7 @@ var ThreadService = class {
       });
     }
     this.assertCodexHooksFileManagement(record.provider);
-    await updateHookJsonEntry({
-      codexHome: this.codexHome,
-      workspacePath: workspace.absPath,
-      input
-    });
-    await trustHookForInput(runtime, workspace.absPath, input);
+    await this.codexManagement.updateHookEntry(runtime, workspace.absPath, input);
     return this.listThreadHooks(localThreadId);
   }
   async trustThreadHook(localThreadId, input) {
@@ -13051,7 +13239,7 @@ var ThreadService = class {
     const workspace = getWorkspaceRecordById(this.db, record.workspaceId);
     if (workspace) {
       const tempDirectory = threadTempDirectoryPath(workspace.absPath, localThreadId);
-      await fs8.rm(tempDirectory, { recursive: true, force: true }).catch(() => {
+      await fs9.rm(tempDirectory, { recursive: true, force: true }).catch(() => {
       });
     }
     this.pendingRequests.delete(localThreadId);
@@ -13226,7 +13414,7 @@ var ThreadService = class {
         if (!record) {
           return;
         }
-        const tokenUsage = isRecord4(event.usage) ? event.usage : null;
+        const tokenUsage = isRecord5(event.usage) ? event.usage : null;
         const usage = buildThreadContextUsageFromPayload(
           tokenUsage,
           record.model
@@ -13242,7 +13430,7 @@ var ThreadService = class {
         );
         const previousCumulativeTotal = this.threadCumulativeTokenUsage.get(record.id);
         const currentCumulativeTotal = buildTurnTokenBreakdown(
-          isRecord4(tokenUsage?.total) ? tokenUsage.total : null
+          isRecord5(tokenUsage?.total) ? tokenUsage.total : null
         );
         if (currentCumulativeTotal) {
           this.threadCumulativeTokenUsage.set(record.id, currentCumulativeTotal);
@@ -13412,10 +13600,22 @@ var ThreadService = class {
         if (!record) {
           return;
         }
-        this.recordTurnItemOrder(record.id, event.providerTurnId, event.itemId);
+        const sequence = this.recordTurnItemOrder(
+          record.id,
+          event.providerTurnId,
+          event.itemId
+        );
+        this.appendLiveAgentMessageDelta(
+          record.id,
+          event.providerTurnId,
+          event.itemId,
+          event.delta,
+          sequence
+        );
         this.emitThreadEvent("thread.output.delta", record.id, {
           turnId: event.providerTurnId,
           itemId: event.itemId,
+          sequence,
           delta: event.delta
         });
         return;
@@ -13489,7 +13689,7 @@ var ThreadService = class {
     const defaultMappedRequest = runtime.mapProviderRequest?.(request, {
       approvalMode: "guarded"
     });
-    const providerSessionIdFromParams = isRecord4(request.params) ? request.params.providerSessionId ?? request.params.threadId ?? request.params.conversationId ?? request.params.sessionId : null;
+    const providerSessionIdFromParams = isRecord5(request.params) ? request.params.providerSessionId ?? request.params.threadId ?? request.params.conversationId ?? request.params.sessionId : null;
     const providerSessionId = defaultMappedRequest?.providerSessionId ?? (typeof providerSessionIdFromParams === "string" ? providerSessionIdFromParams : null);
     const record = providerSessionId ? this.findRecordByProviderSessionId(request.provider, providerSessionId) : null;
     if (!record) {
@@ -13658,9 +13858,32 @@ var ThreadService = class {
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
   }
+  appendLiveAgentMessageDelta(localThreadId, turnId, itemId, delta, sequence) {
+    const current = this.threadLiveItems.get(localThreadId);
+    const currentItems = current?.turnId === turnId ? current.items : [];
+    const existing = currentItems.find((entry) => entry.id === itemId);
+    const nextItem = existing?.kind === "agentMessage" ? {
+      ...existing,
+      text: `${existing.text}${delta}`,
+      sequence
+    } : {
+      id: itemId,
+      kind: "agentMessage",
+      text: delta,
+      sequence
+    };
+    this.persistLiveHistoryItem(localThreadId, turnId, nextItem);
+    this.setLiveItems(localThreadId, {
+      turnId,
+      items: sortHistoryItemsBySequence([
+        ...currentItems.filter((entry) => entry.id !== itemId),
+        nextItem
+      ]),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
   async toThreadHooksDto(provider, workspacePath, entry, fallbackWarnings = []) {
-    const globalHooksPath = path8.join(this.codexHome, "hooks.json");
-    const projectHooksPath = path8.join(workspacePath, ".codex", "hooks.json");
+    const { globalHooksPath, projectHooksPath } = this.codexManagement.hooksPaths(workspacePath);
     const officialHooks = (entry?.hooks ?? []).map((hook) => ({
       key: hook.key,
       eventName: hook.eventName,
@@ -13679,12 +13902,12 @@ var ThreadService = class {
       trustStatus: hook.trustStatus
     }));
     const [globalHooks, projectHooks] = this.isCodexProvider(provider) ? await Promise.all([
-      readLocalHookDtos({
+      this.codexManagement.readLocalHookDtos({
         hooksPath: globalHooksPath,
         source: "user",
         displayOffset: officialHooks.length
       }),
-      readLocalHookDtos({
+      this.codexManagement.readLocalHookDtos({
         hooksPath: projectHooksPath,
         source: "project",
         displayOffset: officialHooks.length + 1e4
@@ -13719,11 +13942,17 @@ var ThreadService = class {
       return null;
     }
     const matchingTurn = turns.find((turn) => turn.id === current.turnId);
-    const materializedItemIds = new Set(
-      matchingTurn?.items.map((item) => item.id) ?? []
+    const materializedItemsById = new Map(
+      matchingTurn?.items.map((item) => [item.id, item]) ?? []
     );
     const nextItems = current.items.filter(
-      (item) => !materializedItemIds.has(item.id)
+      (item) => {
+        const materializedItem = materializedItemsById.get(item.id);
+        if (!materializedItem) {
+          return true;
+        }
+        return typeof item.sequence === "number" && Number.isFinite(item.sequence) && materializedItem.sequence !== item.sequence;
+      }
     );
     if (nextItems.length === current.items.length) {
       return current;
@@ -14266,8 +14495,8 @@ async function registerSystemRoutes(app2) {
 }
 
 // src/routes/threads.ts
-import fs9 from "fs/promises";
-import path9 from "path";
+import fs10 from "fs/promises";
+import path10 from "path";
 import { z as z5 } from "zod";
 var createThreadSchema = z5.object({
   workspaceId: z5.string().uuid(),
@@ -14304,7 +14533,7 @@ var updateThreadSettingsSchema = z5.object({
 });
 var updateThreadGoalSchema = z5.object({
   objective: z5.string().min(1).nullable().optional(),
-  status: z5.enum(["active", "paused", "budgetLimited", "complete"]).nullable().optional(),
+  status: z5.enum(["active", "paused", "budgetLimited", "complete", "terminated"]).nullable().optional(),
   tokenBudget: z5.number().int().positive().nullable().optional()
 }).refine((body) => Object.keys(body).length > 0, {
   message: "At least one goal field must be provided."
@@ -14626,23 +14855,23 @@ async function registerThreadRoutes(app2) {
         message: "Workspace was not found for this thread."
       });
     }
-    const candidatePath = path9.isAbsolute(query.path) ? query.path : path9.resolve(workspace.absPath, query.path);
-    const requestedPath = await fs9.realpath(candidatePath).catch(() => null);
+    const candidatePath = path10.isAbsolute(query.path) ? query.path : path10.resolve(workspace.absPath, query.path);
+    const requestedPath = await fs10.realpath(candidatePath).catch(() => null);
     if (!requestedPath) {
       throw new HttpError(404, {
         code: "not_found",
         message: "Image file was not found."
       });
     }
-    const resolvedWorkspaceRoot = await fs9.realpath(app2.services.config.workspaceRoot).catch(() => path9.resolve(app2.services.config.workspaceRoot));
-    const workspacePrefix = resolvedWorkspaceRoot.endsWith(path9.sep) ? resolvedWorkspaceRoot : `${resolvedWorkspaceRoot}${path9.sep}`;
+    const resolvedWorkspaceRoot = await fs10.realpath(app2.services.config.workspaceRoot).catch(() => path10.resolve(app2.services.config.workspaceRoot));
+    const workspacePrefix = resolvedWorkspaceRoot.endsWith(path10.sep) ? resolvedWorkspaceRoot : `${resolvedWorkspaceRoot}${path10.sep}`;
     if (requestedPath !== resolvedWorkspaceRoot && !requestedPath.startsWith(workspacePrefix)) {
       throw new HttpError(403, {
         code: "forbidden",
         message: "Image path must stay within the configured workspace root."
       });
     }
-    const stats = await fs9.stat(requestedPath).catch(() => null);
+    const stats = await fs10.stat(requestedPath).catch(() => null);
     if (!stats?.isFile()) {
       throw new HttpError(404, {
         code: "not_found",
@@ -14653,7 +14882,7 @@ async function registerThreadRoutes(app2) {
     const contentType = lowerPath.endsWith(".png") ? "image/png" : lowerPath.endsWith(".jpg") || lowerPath.endsWith(".jpeg") ? "image/jpeg" : lowerPath.endsWith(".gif") ? "image/gif" : lowerPath.endsWith(".webp") ? "image/webp" : lowerPath.endsWith(".svg") ? "image/svg+xml" : lowerPath.endsWith(".heic") ? "image/heic" : lowerPath.endsWith(".heif") ? "image/heif" : "application/octet-stream";
     reply.header("Content-Type", contentType);
     reply.header("Cache-Control", "private, max-age=60");
-    return reply.send(await fs9.readFile(requestedPath));
+    return reply.send(await fs10.readFile(requestedPath));
   });
   app2.patch("/api/threads/:id", async (request) => {
     const params = z5.object({ id: z5.string().uuid() }).parse(request.params);
@@ -14827,8 +15056,8 @@ async function registerThreadRoutes(app2) {
 }
 
 // src/routes/workspaces.ts
-import fs10 from "fs/promises";
-import path10 from "path";
+import fs11 from "fs/promises";
+import path11 from "path";
 import { spawn as spawn2 } from "child_process";
 import { z as z6 } from "zod";
 var createWorkspaceSchema = z6.union([
@@ -14868,7 +15097,7 @@ function inferGitRepoName(gitUrl) {
   const normalized = withoutQuery.replace(/[\\/]+$/, "");
   const rawName = normalized.split(/[/:]/).filter(Boolean).at(-1) ?? "";
   const repoName = rawName.endsWith(".git") ? rawName.slice(0, -4) : rawName;
-  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path10.sep)) {
+  if (!repoName || repoName === "." || repoName === ".." || repoName.includes(path11.sep)) {
     throw new HttpError(400, {
       code: "bad_request",
       message: "Unable to infer a target directory from the Git URL."
@@ -14878,7 +15107,7 @@ function inferGitRepoName(gitUrl) {
 }
 async function pathExists2(absPath) {
   try {
-    await fs10.stat(absPath);
+    await fs11.stat(absPath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -14933,7 +15162,7 @@ async function registerWorkspaceRoutes(app2) {
   });
   app2.get("/api/workspaces/tree", async (request) => {
     const query = treeQuerySchema.parse(request.query);
-    const requestedPath = query.path ? path10.resolve(query.path) : app2.services.config.workspaceRoot;
+    const requestedPath = query.path ? path11.resolve(query.path) : app2.services.config.workspaceRoot;
     const tree = await readWorkspaceTree({
       rootPath: app2.services.config.workspaceRoot,
       targetPath: requestedPath,
@@ -14965,7 +15194,7 @@ async function registerWorkspaceRoutes(app2) {
     let validated;
     if ("gitUrl" in body) {
       const repoName = inferGitRepoName(body.gitUrl);
-      const targetPath = path10.join(settings.devHome, repoName);
+      const targetPath = path11.join(settings.devHome, repoName);
       if (await pathExists2(targetPath)) {
         throw new HttpError(409, {
           code: "conflict",
@@ -15074,8 +15303,8 @@ async function registerWorkspaceRoutes(app2) {
 }
 
 // src/provider-host-config-service.ts
-import fs11 from "fs/promises";
-import path11 from "path";
+import fs12 from "fs/promises";
+import path12 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 function providerError(message, statusCode = 404) {
   const error = new Error(message);
@@ -15083,23 +15312,23 @@ function providerError(message, statusCode = 404) {
   return error;
 }
 function resolveProviderHostFilePath(providerHome, name) {
-  return path11.join(providerHome, name);
+  return path12.join(providerHome, name);
 }
 function resolveArchiveRoot(providerHome) {
-  return path11.join(providerHome, "supervisor-config-archives");
+  return path12.join(providerHome, "supervisor-config-archives");
 }
 function resolveArchiveIndexPath(providerHome) {
-  return path11.join(resolveArchiveRoot(providerHome), "index.json");
+  return path12.join(resolveArchiveRoot(providerHome), "index.json");
 }
 function resolveArchivePath(providerHome, archiveId) {
-  return path11.join(resolveArchiveRoot(providerHome), archiveId);
+  return path12.join(resolveArchiveRoot(providerHome), archiveId);
 }
 function defaultArchiveLabel(createdAt) {
   return `Backup ${createdAt.replace("T", " ").replace(/\.\d{3}Z$/, " UTC")}`;
 }
 async function readArchiveIndex(providerHome) {
   try {
-    const raw = await fs11.readFile(resolveArchiveIndexPath(providerHome), "utf8");
+    const raw = await fs12.readFile(resolveArchiveIndexPath(providerHome), "utf8");
     const parsed = JSON.parse(raw);
     return {
       archives: Array.isArray(parsed.archives) ? parsed.archives : []
@@ -15113,8 +15342,8 @@ async function readArchiveIndex(providerHome) {
 }
 async function writeArchiveIndex(providerHome, index) {
   const root = resolveArchiveRoot(providerHome);
-  await fs11.mkdir(root, { recursive: true });
-  await fs11.writeFile(
+  await fs12.mkdir(root, { recursive: true });
+  await fs12.writeFile(
     resolveArchiveIndexPath(providerHome),
     `${JSON.stringify(index, null, 2)}
 `,
@@ -15185,7 +15414,7 @@ var ProviderHostConfigService = class {
     const fileName = this.assertHostFile(provider, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
     try {
-      const content = await fs11.readFile(filePath, "utf8");
+      const content = await fs12.readFile(filePath, "utf8");
       return {
         name: fileName,
         path: filePath,
@@ -15208,8 +15437,8 @@ var ProviderHostConfigService = class {
     const providerHome = this.providerHome(provider);
     const fileName = this.assertHostFile(provider, name);
     const filePath = resolveProviderHostFilePath(providerHome, fileName);
-    await fs11.mkdir(path11.dirname(filePath), { recursive: true });
-    await fs11.writeFile(filePath, input.content, "utf8");
+    await fs12.mkdir(path12.dirname(filePath), { recursive: true });
+    await fs12.writeFile(filePath, input.content, "utf8");
     return this.readFile(provider, fileName);
   }
   async listArchives(provider) {
@@ -15235,7 +15464,7 @@ var ProviderHostConfigService = class {
         }
       ])
     );
-    await fs11.mkdir(archivePath, { recursive: true });
+    await fs12.mkdir(archivePath, { recursive: true });
     for (const name of fileNames) {
       const hostFile = await this.readFile(provider, name);
       files[name] = {
@@ -15243,7 +15472,7 @@ var ProviderHostConfigService = class {
         exists: hostFile.exists
       };
       if (hostFile.exists) {
-        await fs11.writeFile(path11.join(archivePath, name), hostFile.content, "utf8");
+        await fs12.writeFile(path12.join(archivePath, name), hostFile.content, "utf8");
       }
     }
     const archive = {
@@ -15279,14 +15508,14 @@ var ProviderHostConfigService = class {
     const fileNames = this.archiveFileNames(provider);
     const { archive } = await findArchiveOrThrow(providerHome, id);
     const archivePath = resolveArchivePath(providerHome, archive.id);
-    await fs11.mkdir(providerHome, { recursive: true });
+    await fs12.mkdir(providerHome, { recursive: true });
     for (const name of fileNames) {
       const hostPath = resolveProviderHostFilePath(providerHome, name);
       if (archive.files[name]?.exists) {
-        const content = await fs11.readFile(path11.join(archivePath, name), "utf8");
-        await fs11.writeFile(hostPath, content, "utf8");
+        const content = await fs12.readFile(path12.join(archivePath, name), "utf8");
+        await fs12.writeFile(hostPath, content, "utf8");
       } else {
-        await fs11.rm(hostPath, { force: true });
+        await fs12.rm(hostPath, { force: true });
       }
     }
     await runtime.stop();
@@ -15299,12 +15528,12 @@ var ProviderHostConfigService = class {
 };
 
 // src/shell/shell-session-service.ts
-import fs12 from "fs/promises";
+import fs13 from "fs/promises";
 import os3 from "os";
-import path12 from "path";
+import path13 from "path";
 async function pathExists3(filePath) {
   try {
-    await fs12.access(filePath);
+    await fs13.access(filePath);
     return true;
   } catch {
     return false;
@@ -15329,7 +15558,7 @@ function basenameFromPath2(filePath) {
   if (!normalized) {
     return "";
   }
-  return path12.basename(normalized) || normalized;
+  return path13.basename(normalized) || normalized;
 }
 function isInteractiveShellCommand(command) {
   const normalized = (command ?? "").trim().toLowerCase();
@@ -15490,11 +15719,11 @@ function buildShellPromptInitScriptContents(command) {
 async function ensureShellPromptInitScript(command) {
   const normalized = command.trim().toLowerCase();
   const extension = normalized === "zsh" ? "zsh" : "sh";
-  const filePath = path12.join(
+  const filePath = path13.join(
     os3.tmpdir(),
     `remote-codex-shell-prompt.${extension}`
   );
-  await fs12.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
+  await fs13.writeFile(filePath, buildShellPromptInitScriptContents(command), "utf8");
   return filePath;
 }
 async function buildShellPromptInitCommand(command, options = {}) {
@@ -16080,8 +16309,8 @@ var ShellSessionService = class {
 };
 
 // src/shell/tmux-manager.ts
-import fs13 from "fs";
-import path13 from "path";
+import fs14 from "fs";
+import path14 from "path";
 import { spawn as spawnChild } from "child_process";
 async function defaultExecCommand(command, args) {
   return await new Promise((resolve, reject) => {
@@ -16108,17 +16337,17 @@ async function defaultExecCommand(command, args) {
   });
 }
 function resolveExecutablePath(command) {
-  if (command.includes(path13.sep)) {
+  if (command.includes(path14.sep)) {
     return command;
   }
   const searchPath = process.env.PATH ?? "";
-  for (const entry of searchPath.split(path13.delimiter)) {
+  for (const entry of searchPath.split(path14.delimiter)) {
     const trimmed = entry.trim();
     if (!trimmed) {
       continue;
     }
-    const candidate = path13.join(trimmed, command);
-    if (fs13.existsSync(candidate)) {
+    const candidate = path14.join(trimmed, command);
+    if (fs14.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -16447,16 +16676,16 @@ var HttpError = class extends Error {
 };
 function findRepoRoot(start = process.cwd()) {
   if (process.env.REMOTE_CODEX_REPO_ROOT) {
-    return path14.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
+    return path15.resolve(process.env.REMOTE_CODEX_REPO_ROOT);
   }
-  let current = path14.resolve(start);
-  while (current !== path14.dirname(current)) {
-    if (fs14.existsSync(path14.join(current, "pnpm-workspace.yaml")) && fs14.existsSync(path14.join(current, "scripts", "service-restart.mjs"))) {
+  let current = path15.resolve(start);
+  while (current !== path15.dirname(current)) {
+    if (fs15.existsSync(path15.join(current, "pnpm-workspace.yaml")) && fs15.existsSync(path15.join(current, "scripts", "service-restart.mjs"))) {
       return current;
     }
-    current = path14.dirname(current);
+    current = path15.dirname(current);
   }
-  return path14.resolve(process.cwd());
+  return path15.resolve(process.cwd());
 }
 function createServiceLifecycle() {
   return {
@@ -16468,8 +16697,8 @@ function createServiceLifecycle() {
         });
       }
       const repoRoot = findRepoRoot();
-      const restartScript = path14.join(repoRoot, "scripts", "service-restart.mjs");
-      if (!fs14.existsSync(restartScript) || !fs14.existsSync(path14.join(repoRoot, "pnpm-workspace.yaml"))) {
+      const restartScript = path15.join(repoRoot, "scripts", "service-restart.mjs");
+      if (!fs15.existsSync(restartScript) || !fs15.existsSync(path15.join(repoRoot, "pnpm-workspace.yaml"))) {
         throw new HttpError(503, {
           code: "service_unavailable",
           message: "Build and restart requires a Remote Codex source checkout. Set REMOTE_CODEX_REPO_ROOT to the checkout path, or update the npm package with npm install -g remote-codex@latest."
@@ -16500,7 +16729,7 @@ function buildApp(options = {}) {
     eventBus,
     runtimeBootstrap.localCodexSessionStore,
     config.workspaceRoot,
-    config.codexHome
+    runtimeBootstrap.codexManagement
   );
   const shellService = options.shellService ?? new ShellSessionService(database.db, eventBus, new TmuxManager());
   const providerHostConfigService = new ProviderHostConfigService(
@@ -16810,7 +17039,7 @@ function makeShellErrorEnvelope(shellId, error) {
 }
 
 // src/index.ts
-if (fs15.existsSync(".env")) {
+if (fs16.existsSync(".env")) {
   process.loadEnvFile?.(".env");
 }
 var app = buildApp();