replicas-engine 0.1.224 → 0.1.226

package/dist/src/index.js

@@ -20,6 +20,11 @@ import { readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 
+// ../shared/src/type-guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
 // ../shared/src/agent.ts
 var CODEX_REASONING_EFFORT_BY_THINKING_LEVEL = {
   low: "low",
@@ -35,6 +40,7 @@ function codexReasoningEffortForThinkingLevel(thinkingLevel) {
 var ACCEPTED_USER_MESSAGE_SOURCE = "replicas-chat-turn-accepted";
 var USER_MESSAGE_ID_PAYLOAD_KEY = "replicasMessageId";
 var CODEX_ASP_ITEM_ID_PAYLOAD_KEY = "codexAspItemId";
+var CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE = "codex-asp-transcript-updated";
 var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
 var COMPACTION_STATUS_EVENT_TYPE = "compaction-status";
 var CHAT_GOAL_EVENT_TYPE = "chat-goal";
@@ -1648,7 +1654,7 @@ var DEFAULT_WARM_HOOK_TIMEOUT_MS = 5 * 60 * 1e3;
 var MAX_WARM_HOOK_TIMEOUT_MS = 15 * 60 * 1e3;
 var DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS = 1e5;
 var HOOK_EXEC_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function clampWarmHookTimeoutMs(timeoutMs) {
@@ -1672,7 +1678,7 @@ function parseWarmHookConfig(value, filename = "replicas.json") {
   if (typeof value === "string") {
     return value;
   }
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     throw new Error(`Invalid ${filename}: "warmHook" must be a string or object`);
   }
   if (!Array.isArray(value.commands) || !value.commands.every((entry) => typeof entry === "string")) {
@@ -1708,11 +1714,11 @@ function resolveWarmHookConfig(value) {
 
 // ../shared/src/replicas-config.ts
 var REPLICAS_CONFIG_FILENAMES = ["replicas.json", "replicas.yaml", "replicas.yml"];
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 function parseReplicasConfig(value, filename = "replicas.json") {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     throw new Error(`Invalid ${filename}: expected an object`);
   }
   const config = {};
@@ -1729,7 +1735,7 @@ function parseReplicasConfig(value, filename = "replicas.json") {
     config.systemPrompt = value.systemPrompt;
   }
   if ("startHook" in value) {
-    if (!isRecord2(value.startHook)) {
+    if (!isRecord3(value.startHook)) {
       throw new Error(`Invalid ${filename}: "startHook" must be an object with "commands" array`);
     }
     const { commands, timeout, separate } = value.startHook;
@@ -1767,7 +1773,7 @@ function isClaudeAuthErrorText(text) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "28-05-2026-royal-york-v1";
+var DAYTONA_SNAPSHOT_ID = "28-05-2026-royal-york-v3";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -1806,6 +1812,15 @@ var IMAGE_MEDIA_TYPES = ["image/png", "image/jpeg", "image/gif", "image/webp"];
 
 // ../shared/src/engine/v1.ts
 var MERGED_MESSAGE_SEPARATOR = "\n\n<!-- replicas:merged -->\n\n";
+function normalizeCodexAspTranscriptStatus(status, failed = false) {
+  if (failed || status === "failed") return "failed";
+  if (status === "completed") return "completed";
+  return "in_progress";
+}
+function isCodexAspTranscript(value) {
+  if (!isRecord(value)) return false;
+  return typeof value.threadId === "string" && typeof value.updatedAt === "string" && Array.isArray(value.turns);
+}
 
 // ../shared/src/routes/codex.ts
 var CODEX_AUTH_ENV_KEYS = [
@@ -1879,14 +1894,6 @@ var AUDIT_LOG_ACTION = {
 };
 var AUDIT_LOG_ACTIONS = Object.values(AUDIT_LOG_ACTION);
 
-// ../shared/src/object-store/types.ts
-var MEDIA_KIND = {
-  IMAGE: "image",
-  VIDEO: "video",
-  AUDIO: "audio"
-};
-var MEDIA_KINDS = [MEDIA_KIND.IMAGE, MEDIA_KIND.VIDEO, MEDIA_KIND.AUDIO];
-
 // ../shared/src/agent-event-utils.ts
 function getUserMessage(event) {
   return event.type === "event_msg" && event.payload.type === "user_message" && typeof event.payload.message === "string" ? event.payload.message : null;
@@ -1899,9 +1906,12 @@ function getUserMessageItemId(event) {
   const itemId = event.payload[CODEX_ASP_ITEM_ID_PAYLOAD_KEY];
   return typeof itemId === "string" ? itemId : null;
 }
+function parseTimestampMs(timestamp) {
+  const value = Date.parse(timestamp);
+  return Number.isFinite(value) ? value : 0;
+}
 function getEventTimestampMs(event) {
-  const value = Date.parse(event.timestamp);
-  return Number.isNaN(value) ? 0 : value;
+  return parseTimestampMs(event.timestamp);
 }
 function areSameUserMessageEvents(a, b) {
   const aMessage = getUserMessage(a);
@@ -1915,21 +1925,17 @@ function areSameUserMessageEvents(a, b) {
   if (aItemId || bItemId) return aItemId === bItemId;
   return Math.abs(getEventTimestampMs(a) - getEventTimestampMs(b)) <= 3e4;
 }
-function mergeAgentEvents(primary, supplemental, options) {
-  const merged = [...primary];
-  const { areDuplicates, mergeEvent } = options;
-  for (const event of supplemental) {
-    const existingIndex = merged.findIndex((existing) => areDuplicates(existing, event));
-    if (existingIndex === -1) {
-      merged.push(event);
-      continue;
-    }
-    if (mergeEvent) {
-      merged[existingIndex] = mergeEvent(merged[existingIndex], event);
-    }
-  }
-  return merged;
-}
+
+// ../shared/src/display-message/parsers/codex-asp-parser.ts
+var DUPLICATE_WINDOW_MS = 5 * 60 * 1e3;
+
+// ../shared/src/object-store/types.ts
+var MEDIA_KIND = {
+  IMAGE: "image",
+  VIDEO: "video",
+  AUDIO: "audio"
+};
+var MEDIA_KINDS = [MEDIA_KIND.IMAGE, MEDIA_KIND.VIDEO, MEDIA_KIND.AUDIO];
 
 // src/runtime-env-loader.ts
 function loadRuntimeEnvFile() {
@@ -2013,8 +2019,7 @@ function loadEngineEnv() {
     AWS_REGION: readEnv("AWS_REGION"),
     REPLICAS_CLAUDE_AUTH_METHOD: parseClaudeAuthMethod(readEnv("REPLICAS_CLAUDE_AUTH_METHOD")),
     REPLICAS_CODEX_AUTH_METHOD: parseCodexAuthMethod(readEnv("REPLICAS_CODEX_AUTH_METHOD")),
-    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT"),
-    CODEX_ASP_ENABLED: readEnv("CODEX_ASP_ENABLED")?.toLowerCase() === "true"
+    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT")
   };
   if (!IS_WARMING_MODE && !env.WORKSPACE_ID) {
     console.error("WORKSPACE_ID is not set \u2014 this is required in normal (non-warming) mode");
@@ -2423,7 +2428,7 @@ import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
 
 // src/utils/type-guards.ts
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -2455,10 +2460,10 @@ async function updateEngineState(updater) {
   });
 }
 function isEngineRepoDiff(value) {
-  return isRecord3(value) && typeof value.added === "number" && typeof value.removed === "number";
+  return isRecord4(value) && typeof value.added === "number" && typeof value.removed === "number";
 }
 function coerceRepoState(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return null;
   }
   if (typeof value.name !== "string") return null;
@@ -2484,11 +2489,11 @@ function coerceRepoState(value) {
   };
 }
 function coerceEngineState(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return {};
   }
   const partial = {};
-  if (isRecord3(value.repos)) {
+  if (isRecord4(value.repos)) {
     const repos = {};
     for (const [repoName, repoState] of Object.entries(value.repos)) {
       const coerced = coerceRepoState(repoState);
@@ -3700,10 +3705,10 @@ import { homedir as homedir11 } from "os";
 // src/utils/jsonl-reader.ts
 import { readFile as readFile6 } from "fs/promises";
 function isJsonlEvent(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return false;
   }
-  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord3(value.payload);
+  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord4(value.payload);
 }
 function parseJsonlEvents(lines) {
   const events = [];
@@ -5349,765 +5354,279 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   }
 };
 
-// src/managers/codex-manager.ts
-import { Codex } from "@openai/codex-sdk";
-import { readdir as readdir3, stat as stat2, writeFile as writeFile8, mkdir as mkdir10, readFile as readFile7 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir12 } from "os";
-import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-
-// src/utils/codex-quota.ts
-function buildCodexRateLimitsSnapshot(fields) {
-  if (fields.unlimited === true) return null;
-  let state = "ok";
-  if (fields.hasCredits === false) {
-    state = "out_of_credits";
-  } else if (fields.rateLimitResetType !== null) {
-    state = "rate_limited";
-  }
-  return {
-    state,
-    balance: fields.balance,
-    rateLimitResetType: fields.rateLimitResetType,
-    planType: fields.planType
-  };
-}
-function extractCodexRateLimitsSnapshotFromJsonl(parsed) {
-  if (!isRecord3(parsed)) return null;
-  const payload = isRecord3(parsed.payload) ? parsed.payload : parsed;
-  const rateLimits = isRecord3(payload.rate_limits) ? payload.rate_limits : null;
-  if (!rateLimits) return null;
-  const credits = isRecord3(rateLimits.credits) ? rateLimits.credits : null;
-  const hasCredits = credits && typeof credits.has_credits === "boolean" ? credits.has_credits : null;
-  const unlimited = credits && typeof credits.unlimited === "boolean" ? credits.unlimited : null;
-  const balance = credits && typeof credits.balance === "string" ? credits.balance : null;
-  const rateLimitResetType = typeof rateLimits.rate_limit_reached_type === "string" && rateLimits.rate_limit_reached_type.length > 0 ? rateLimits.rate_limit_reached_type : null;
-  const planType = typeof rateLimits.plan_type === "string" ? rateLimits.plan_type : null;
-  return buildCodexRateLimitsSnapshot({
-    unlimited,
-    hasCredits,
-    balance,
-    rateLimitResetType,
-    planType
-  });
-}
-var CodexQuotaStatusTracker = class {
-  lastEmittedQuotaState = "ok";
-  latestQuotaSnapshot = null;
-  quotaBlocked = false;
-  get blocked() {
-    return this.quotaBlocked;
-  }
-  get latestSnapshot() {
-    return this.latestQuotaSnapshot;
-  }
-  prime(snapshot) {
-    this.latestQuotaSnapshot = snapshot;
-    this.quotaBlocked = snapshot.state === "out_of_credits";
-  }
-  apply(snapshot, force = false) {
-    const stateChanged = snapshot.state !== this.lastEmittedQuotaState;
-    if (!stateChanged && !force) {
-      return null;
-    }
-    this.lastEmittedQuotaState = snapshot.state;
-    this.quotaBlocked = snapshot.state === "out_of_credits";
-    this.latestQuotaSnapshot = snapshot;
-    const payload = {
-      state: snapshot.state,
-      balance: snapshot.balance,
-      rateLimitResetType: snapshot.rateLimitResetType,
-      planType: snapshot.planType
-    };
-    const event = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      type: CODEX_QUOTA_STATUS_EVENT_TYPE,
-      payload
-    };
-    return event;
-  }
-};
+// src/managers/codex-asp/app-server-process.ts
+import { spawn } from "child_process";
+import { EventEmitter as EventEmitter2 } from "events";
 
-// src/utils/codex-auth.ts
-function isCodexAuthError(error) {
-  const msg = error instanceof Error ? error.message : String(error);
-  const lower = msg.toLowerCase();
-  return lower.includes("unauthorized") || lower.includes("authentication") || lower.includes("invalid api key") || lower.includes("incorrect api key") || lower.includes("api key") && lower.includes("invalid") || lower.includes("401") || lower.includes('codexerrorinfo="unauthorized"') || lower.includes("codexerrorinfo=unauthorized");
+// src/managers/codex-asp/asp-client.ts
+import { EventEmitter } from "events";
+var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
 }
-
-// src/managers/codex-manager.ts
-var DEFAULT_MODEL = "gpt-5.5";
-var CODEX_CONFIG_PATH = join14(homedir12(), ".codex", "config.toml");
-function isJsonlEvent2(value) {
-  if (!isRecord3(value)) {
-    return false;
+var AspClient = class {
+  stdin;
+  stdout;
+  emitter = new EventEmitter();
+  pending = /* @__PURE__ */ new Map();
+  nextId = 1;
+  lineBuffer = "";
+  disposed = false;
+  get isDisposed() {
+    return this.disposed;
   }
-  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord3(value.payload);
-}
-function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
-}
-var CodexManager = class extends CodingAgentManager {
-  codex;
-  currentThreadId = null;
-  currentThread = null;
-  activeAbortController = null;
-  quotaStatus = new CodexQuotaStatusTracker();
   constructor(options) {
-    super(options);
-    this.codex = this.createCodexClient();
-    this.initializeManager(this.processMessageInternal.bind(this));
+    this.stdin = options.stdin;
+    this.stdout = options.stdout;
+    this.stdout.setEncoding("utf8");
+    this.stdout.on("data", this.handleStdoutData);
+    this.stdin.on("error", this.handleStdinError);
   }
-  createCodexClient() {
-    const codexApiKey = resolveCodexApiKey();
-    return new Codex({
-      env: buildCodexAgentEnv(),
-      ...codexApiKey ? { apiKey: codexApiKey } : {}
-    });
+  on(event, listener) {
+    this.emitter.on(event, listener);
   }
-  resetCodexClient() {
-    this.codex = this.createCodexClient();
-    this.currentThread = null;
+  off(event, listener) {
+    this.emitter.off(event, listener);
   }
-  async initialize() {
-    if (this.initialSessionId) {
-      this.currentThreadId = this.initialSessionId;
-      console.log(`[CodexManager] Restored thread ID from persisted state: ${this.currentThreadId}`);
+  async request(method, params, opts) {
+    if (this.disposed) {
+      throw new Error(`Cannot send ${method}: ASP client disposed`);
     }
+    const id = this.nextId;
+    this.nextId += 1;
+    const promise = new Promise((resolve3, reject) => {
+      const timeoutMs = opts?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+      const timer = timeoutMs > 0 ? setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`ASP request timed out for ${method}`));
+      }, timeoutMs) : null;
+      this.pending.set(id, { resolve: resolve3, reject, method, timer });
+    });
+    this.write({ method, id, params });
+    return promise;
   }
-  async flushQuotaSnapshotFromCurrentSession() {
-    if (!this.currentThreadId) return;
+  notify(method, params) {
+    if (this.disposed) {
+      return;
+    }
     try {
-      const sessionFile = await this.findSessionFile(this.currentThreadId);
-      if (!sessionFile) return;
-      const content = await readFile7(sessionFile, "utf-8");
-      const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
-      let latest = null;
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
-          if (snapshot) {
-            latest = snapshot;
-          }
-        } catch {
-        }
-      }
-      if (latest) {
-        this.emitQuotaStatus(latest);
-      }
+      this.write(params === void 0 ? { method } : { method, params });
     } catch (error) {
-      console.warn("[CodexManager] Failed to flush quota snapshot from session:", error);
+      console.warn(`[AspClient] Failed to send notification ${method}:`, error);
     }
   }
-  emitQuotaStatus(snapshot, force = false) {
-    const event = this.quotaStatus.apply(snapshot, force);
-    if (event) this.onEvent(event);
+  respond(id, result) {
+    if (this.disposed) {
+      return;
+    }
+    try {
+      this.write({ id, result });
+    } catch (error) {
+      console.warn(`[AspClient] Failed to send response ${String(id)}:`, error);
+    }
   }
-  async interruptActiveTurn() {
-    if (this.activeAbortController) {
-      this.activeAbortController.abort();
+  dispose(reason = new Error("ASP client disposed")) {
+    if (this.disposed) {
+      return;
     }
+    this.disposed = true;
+    this.stdout.off("data", this.handleStdoutData);
+    this.stdin.removeListener("error", this.handleStdinError);
+    for (const [id, pending] of this.pending) {
+      if (pending.timer) {
+        clearTimeout(pending.timer);
+      }
+      pending.reject(new Error(`${reason.message} while waiting for ${pending.method}`));
+      this.pending.delete(id);
+    }
+    this.lineBuffer = "";
+    this.emitter.emit("dispose", reason);
+    this.emitter.removeAllListeners();
   }
-  /**
-   * Update the developer_instructions in ~/.codex/config.toml
-   * This sets the system prompt that Codex will use for this turn
-   */
-  async updateCodexConfig(developerInstructions) {
-    try {
-      const codexDir = join14(homedir12(), ".codex");
-      await mkdir10(codexDir, { recursive: true });
-      let config = {};
-      if (existsSync6(CODEX_CONFIG_PATH)) {
-        try {
-          const existingContent = await readFile7(CODEX_CONFIG_PATH, "utf-8");
-          const parsed = parseToml(existingContent);
-          if (isRecord3(parsed)) {
-            config = parsed;
-          }
-        } catch (parseError) {
-          console.warn("[CodexManager] Failed to parse existing config.toml, starting fresh:", parseError);
-        }
-      }
-      if (developerInstructions) {
-        config.developer_instructions = developerInstructions;
-      } else {
-        delete config.developer_instructions;
+  handleStdoutData = (chunk) => {
+    this.lineBuffer += chunk.toString();
+    let newlineIndex = this.lineBuffer.indexOf("\n");
+    while (newlineIndex >= 0) {
+      const line = this.lineBuffer.slice(0, newlineIndex).trim();
+      this.lineBuffer = this.lineBuffer.slice(newlineIndex + 1);
+      if (line.length > 0) {
+        this.handleLine(line);
       }
-      const tomlContent = stringifyToml(config);
-      await writeFile8(CODEX_CONFIG_PATH, tomlContent, "utf-8");
-      console.log("[CodexManager] Updated config.toml with developer_instructions");
-    } catch (error) {
-      console.error("[CodexManager] Failed to update config.toml:", error);
+      newlineIndex = this.lineBuffer.indexOf("\n");
     }
-  }
-  async processMessageInternal(request) {
+  };
+  handleStdinError = (error) => {
+    this.dispose(new Error(`ASP stdin error: ${error.message}`));
+  };
+  handleLine(line) {
+    let parsed;
     try {
-      await this.executeCodexTurn(request);
+      parsed = JSON.parse(line);
     } catch (error) {
-      if (isCodexAuthError(error)) {
-        const refreshed = await codexTokenManager.fetchFreshCredentials(error instanceof Error ? error.message : String(error));
-        if (refreshed) {
-          this.resetCodexClient();
-          await this.executeCodexTurn(request);
-          return;
-        }
-      }
-      throw error;
+      console.warn("[AspClient] Failed to parse ASP JSON line:", error);
+      return;
     }
-  }
-  async executeCodexTurn(request) {
-    if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
-      await this.flushQuotaSnapshotFromCurrentSession();
-      if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
-        this.emitQuotaStatus(this.quotaStatus.latestSnapshot, true);
-        try {
-          await this.onTurnComplete();
-        } catch (error) {
-          console.error("[CodexManager] onTurnComplete failed during quota-blocked turn:", error);
-        }
-        return;
-      }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      console.warn("[AspClient] Ignoring non-object ASP message");
+      return;
     }
-    const {
-      message,
-      model,
-      customInstructions,
-      images,
-      permissionMode,
-      thinkingLevel
-    } = request;
-    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
-    let tempImagePaths = [];
-    let stopTail = null;
-    let abortController = null;
-    try {
-      if (images && images.length > 0) {
-        const normalizedImages = await normalizeImages(images);
-        tempImagePaths = await saveNormalizedImagesToTempFiles(normalizedImages);
-      }
-      const developerInstructions = this.buildCombinedInstructions(customInstructions);
-      await this.updateCodexConfig(developerInstructions);
-      const sandboxMode = "danger-full-access";
-      const webSearchMode = "live";
-      const codexReasoningEffort = codexReasoningEffortForThinkingLevel(thinkingLevel);
-      const additionalDirectories = await getAgentAdditionalDirectories();
-      const threadOptions = {
-        workingDirectory: this.workingDirectory,
-        skipGitRepoCheck: true,
-        sandboxMode,
-        model: model || DEFAULT_MODEL,
-        webSearchMode,
-        additionalDirectories,
-        ...codexReasoningEffort ? { modelReasoningEffort: codexReasoningEffort } : {}
-      };
-      abortController = new AbortController();
-      this.activeAbortController = abortController;
-      if (this.currentThreadId) {
-        this.currentThread = this.codex.resumeThread(this.currentThreadId, threadOptions);
-      } else {
-        this.currentThread = this.codex.startThread(threadOptions);
-        const { events } = await this.currentThread.runStreamed("Hello", { signal: abortController.signal });
-        for await (const event of events) {
-          if (event.type === "thread.started") {
-            this.currentThreadId = event.thread_id;
-            await this.onSaveSessionId(this.currentThreadId);
-            console.log(`[CodexManager] Captured and persisted thread ID: ${this.currentThreadId}`);
-          }
-        }
-        if (!this.currentThreadId && this.currentThread.id) {
-          this.currentThreadId = this.currentThread.id;
-          await this.onSaveSessionId(this.currentThreadId);
-          console.log(`[CodexManager] Captured and persisted thread ID from thread.id: ${this.currentThreadId}`);
-        }
-      }
-      stopTail = this.currentThreadId ? await this.startSessionTail(this.currentThreadId) : null;
-      let input;
-      if (tempImagePaths.length > 0) {
-        const inputItems = [
-          { type: "text", text: message },
-          ...tempImagePaths.map((path4) => ({ type: "local_image", path: path4 }))
-        ];
-        input = inputItems;
-      } else {
-        input = message;
-      }
-      try {
-        const { events } = await this.currentThread.runStreamed(input, { signal: abortController.signal });
-        const linearForwarder = new LinearEventForwarder(linearSessionId);
-        for await (const event of events) {
-          if (linearSessionId) {
-            linearForwarder.sendPlan(extractPlanFromCodexEvent(event));
-            linearForwarder.sendEvent(convertCodexEvent(event, linearSessionId));
-          }
-        }
-        linearForwarder.flushThoughtAsResponse();
-      } catch (error) {
-        await this.flushQuotaSnapshotFromCurrentSession();
-        if (this.quotaStatus.blocked) {
-          return;
-        }
-        throw error;
-      }
-    } finally {
-      if (stopTail) {
-        await stopTail();
-      }
-      await removeTempImageFiles(tempImagePaths);
-      try {
-        await this.onTurnComplete();
-      } catch (error) {
-        console.error("[CodexManager] onTurnComplete failed:", error);
-      }
-      this.activeAbortController = null;
+    const message = parsed;
+    const hasRequestId = typeof message.id === "number" || typeof message.id === "string";
+    if (hasRequestId && (hasOwn(message, "result") || hasOwn(message, "error"))) {
+      this.handleResponse(message);
+      return;
+    }
+    if (hasRequestId && typeof message.method === "string") {
+      this.emitter.emit("serverRequest", message);
+      return;
+    }
+    if (!hasOwn(message, "id") && typeof message.method === "string") {
+      this.emitter.emit("notification", message);
     }
   }
-  async getHistory() {
-    if (!this.currentThreadId) {
-      return {
-        thread_id: null,
-        events: []
-      };
+  handleResponse(message) {
+    if (typeof message.id !== "number") {
+      console.warn("[AspClient] Ignoring response with non-numeric request id");
+      return;
     }
-    const sessionFile = await this.findSessionFile(this.currentThreadId);
-    if (!sessionFile) {
-      return {
-        thread_id: this.currentThreadId,
-        events: []
-      };
+    const pending = this.pending.get(message.id);
+    if (!pending) {
+      console.warn(`[AspClient] Ignoring response for unknown request id ${message.id}`);
+      return;
     }
-    const events = await readJSONL(sessionFile);
-    return {
-      thread_id: this.currentThreadId,
-      events
-    };
+    this.pending.delete(message.id);
+    if (pending.timer) {
+      clearTimeout(pending.timer);
+    }
+    if (hasOwn(message, "error")) {
+      pending.reject(this.createRpcError(pending.method, message.error));
+      return;
+    }
+    pending.resolve(message.result);
   }
-  // Helper methods for finding session files
-  async findSessionFile(threadId) {
-    const sessionsDir = join14(homedir12(), ".codex", "sessions");
-    try {
-      const now = /* @__PURE__ */ new Date();
-      const year = now.getFullYear();
-      const month = String(now.getMonth() + 1).padStart(2, "0");
-      const day = String(now.getDate()).padStart(2, "0");
-      const todayDir = join14(sessionsDir, String(year), month, day);
-      const file = await this.findFileInDirectory(todayDir, threadId);
-      if (file) return file;
-      for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
-        const date = new Date(now);
-        date.setDate(date.getDate() - daysAgo);
-        const searchYear = date.getFullYear();
-        const searchMonth = String(date.getMonth() + 1).padStart(2, "0");
-        const searchDay = String(date.getDate()).padStart(2, "0");
-        const searchDir = join14(sessionsDir, String(searchYear), searchMonth, searchDay);
-        const file2 = await this.findFileInDirectory(searchDir, threadId);
-        if (file2) return file2;
-      }
-      return null;
-    } catch (error) {
-      return null;
+  createRpcError(method, error) {
+    if (typeof error !== "object" || error === null || Array.isArray(error)) {
+      return new Error(`ASP request failed for ${method}`);
     }
+    const rpcError = error;
+    const code = typeof rpcError.code === "number" ? ` ${rpcError.code}` : "";
+    const message = typeof rpcError.message === "string" ? rpcError.message : "Unknown ASP error";
+    const data = hasOwn(rpcError, "data") ? ` data=${JSON.stringify(rpcError.data)}` : "";
+    return new Error(`ASP request failed for ${method}:${code} ${message}${data}`);
   }
-  async findFileInDirectory(directory, threadId) {
+  write(message) {
     try {
-      const files = await readdir3(directory);
-      for (const file of files) {
-        if (file.endsWith(".jsonl") && file.includes(threadId)) {
-          const fullPath = join14(directory, file);
-          const stats = await stat2(fullPath);
-          if (stats.isFile()) {
-            return fullPath;
-          }
+      this.stdin.write(`${JSON.stringify(message)}
+`, (error) => {
+        if (error) {
+          this.dispose(new Error(`ASP write failed: ${error.message}`));
         }
-      }
-      return null;
+      });
     } catch (error) {
-      return null;
-    }
-  }
-  async waitForSessionFile(threadId, timeoutMs = 5e3) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-      const sessionFile = await this.findSessionFile(threadId);
-      if (sessionFile) {
-        return sessionFile;
-      }
-      await sleep(100);
-    }
-    return null;
-  }
-  // @openai/codex-sdk doesn't expose manual /compact (TUI-only); we only mirror the auto-compaction rollout entries to the UI.
-  trackNativeCompaction(event) {
-    if (event.type === "compacted") {
-      this.setCompacting(false);
-      return;
-    }
-    if (event.type !== "event_msg") return;
-    const msg = event.payload.msg;
-    if (!msg) return;
-    const itemType = msg.payload?.item?.type;
-    if (itemType !== "context_compaction") return;
-    if (msg.type === "item_started") {
-      this.setCompacting(true);
-    } else if (msg.type === "item_completed") {
-      this.setCompacting(false);
-    }
-  }
-  async startSessionTail(threadId) {
-    const sessionFile = await this.waitForSessionFile(threadId);
-    if (!sessionFile) {
-      return async () => {
-      };
+      const writeError = error instanceof Error ? error : new Error("ASP write failed");
+      this.dispose(writeError);
+      throw writeError;
     }
-    let active = true;
-    const seenLines = /* @__PURE__ */ new Set();
-    const seedSeenLines = async () => {
-      try {
-        const content = await readFile7(sessionFile, "utf-8");
-        const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
-        let latest = null;
-        for (const line of lines) {
-          seenLines.add(line);
-          try {
-            const parsed = JSON.parse(line);
-            const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
-            if (snapshot) latest = snapshot;
-          } catch {
-          }
-        }
-        if (latest) {
-          this.quotaStatus.prime(latest);
-        }
-      } catch {
-      }
-    };
-    await seedSeenLines();
-    const pump = async () => {
-      let emitted = 0;
-      try {
-        const content = await readFile7(sessionFile, "utf-8");
-        const lines = content.split("\n");
-        const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
-        for (const line of completeLines) {
-          const trimmed = line.trim();
-          if (!trimmed || seenLines.has(trimmed)) {
-            continue;
-          }
-          seenLines.add(trimmed);
-          try {
-            const parsed = JSON.parse(trimmed);
-            const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
-            if (snapshot) {
-              this.emitQuotaStatus(snapshot);
-            }
-            if (isJsonlEvent2(parsed)) {
-              this.trackNativeCompaction(parsed);
-              this.onEvent(parsed);
-              emitted += 1;
-            }
-          } catch {
-          }
-        }
-      } catch {
-      }
-      return emitted;
-    };
-    const loop = (async () => {
-      while (active) {
-        await pump();
-        await sleep(100);
-      }
-      await pump();
-    })();
-    return async () => {
-      active = false;
-      await loop;
-      const deadline = Date.now() + 1500;
-      while (Date.now() < deadline) {
-        const emitted = await pump();
-        if (emitted > 0) {
-          continue;
-        }
-        await sleep(100);
-      }
-    };
   }
 };
 
 // src/managers/codex-asp/app-server-process.ts
-import { spawn } from "child_process";
-import { EventEmitter as EventEmitter2 } from "events";
-
-// src/managers/codex-asp/asp-client.ts
-import { EventEmitter } from "events";
-var DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
-function hasOwn(record, key) {
-  return Object.prototype.hasOwnProperty.call(record, key);
-}
-var AspClient = class {
-  stdin;
-  stdout;
-  emitter = new EventEmitter();
-  pending = /* @__PURE__ */ new Map();
-  nextId = 1;
-  lineBuffer = "";
-  disposed = false;
-  get isDisposed() {
-    return this.disposed;
-  }
-  constructor(options) {
-    this.stdin = options.stdin;
-    this.stdout = options.stdout;
-    this.stdout.setEncoding("utf8");
-    this.stdout.on("data", this.handleStdoutData);
-    this.stdin.on("error", this.handleStdinError);
+var DEFAULT_CODEX_BINARY = "codex";
+var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
+var ENGINE_PACKAGE_VERSION = "0.1.213";
+var INITIALIZE_METHOD = "initialize";
+var INITIALIZED_NOTIFICATION = "initialized";
+var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
+var AppServerProcess = class {
+  binary;
+  args;
+  env;
+  cwd;
+  emitter = new EventEmitter2();
+  child = null;
+  client = null;
+  shuttingDown = false;
+  constructor(options = {}) {
+    this.binary = options.binary ?? DEFAULT_CODEX_BINARY;
+    this.args = options.args ?? DEFAULT_CODEX_ARGS;
+    this.env = options.env ?? buildCodexAgentEnv();
+    this.cwd = options.cwd ?? ENGINE_ENV.WORKSPACE_ROOT;
   }
   on(event, listener) {
     this.emitter.on(event, listener);
   }
-  off(event, listener) {
-    this.emitter.off(event, listener);
-  }
-  async request(method, params, opts) {
-    if (this.disposed) {
-      throw new Error(`Cannot send ${method}: ASP client disposed`);
+  async start() {
+    if (this.child && this.client) {
+      return { client: this.client };
     }
-    const id = this.nextId;
-    this.nextId += 1;
-    const promise = new Promise((resolve3, reject) => {
-      const timeoutMs = opts?.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-      const timer = timeoutMs > 0 ? setTimeout(() => {
-        this.pending.delete(id);
-        reject(new Error(`ASP request timed out for ${method}`));
-      }, timeoutMs) : null;
-      this.pending.set(id, { resolve: resolve3, reject, method, timer });
+    this.shuttingDown = false;
+    const child = spawn(this.binary, this.args, {
+      cwd: this.cwd,
+      env: this.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+      for (const line of chunk.toString().split("\n")) {
+        if (line.trim().length > 0) {
+          console.error(`[codex-app-server] ${line}`);
+        }
+      }
+    });
+    child.on("exit", (code, signal) => {
+      this.client?.dispose();
+      this.client = null;
+      this.child = null;
+      if (!this.shuttingDown) {
+        console.warn(`[AppServerProcess] codex app-server exited unexpectedly code=${code ?? "null"} signal=${signal ?? "null"}`);
+        this.emitter.emit("exit", code, signal);
+      }
+    });
+    const client = new AspClient({ stdin: child.stdin, stdout: child.stdout });
+    this.client = client;
+    let cleanupEarlyFailureHandlers = () => {
+    };
+    const earlyFailure = new Promise((_resolve, reject) => {
+      const onError = (error) => {
+        reject(error);
+      };
+      const onExit = (code, signal) => {
+        reject(new Error(`codex app-server exited before initialize completed code=${code ?? "null"} signal=${signal ?? "null"}`));
+      };
+      child.once("error", onError);
+      child.once("exit", onExit);
+      cleanupEarlyFailureHandlers = () => {
+        child.off("error", onError);
+        child.off("exit", onExit);
+      };
     });
-    this.write({ method, id, params });
-    return promise;
-  }
-  notify(method, params) {
-    if (this.disposed) {
-      return;
-    }
     try {
-      this.write(params === void 0 ? { method } : { method, params });
+      const initializeParams = {
+        clientInfo: {
+          name: "replicas_engine",
+          title: "Replicas Engine",
+          version: ENGINE_PACKAGE_VERSION
+        },
+        capabilities: {
+          experimentalApi: true,
+          requestAttestation: false,
+          optOutNotificationMethods: null
+        }
+      };
+      await Promise.race([
+        client.request(INITIALIZE_METHOD, initializeParams),
+        earlyFailure
+      ]);
+      cleanupEarlyFailureHandlers();
+      client.notify(INITIALIZED_NOTIFICATION);
+      await this.loginWithConfiguredApiKey(client);
+      return { client };
     } catch (error) {
-      console.warn(`[AspClient] Failed to send notification ${method}:`, error);
-    }
-  }
-  respond(id, result) {
-    if (this.disposed) {
-      return;
-    }
-    try {
-      this.write({ id, result });
-    } catch (error) {
-      console.warn(`[AspClient] Failed to send response ${String(id)}:`, error);
-    }
-  }
-  dispose(reason = new Error("ASP client disposed")) {
-    if (this.disposed) {
-      return;
-    }
-    this.disposed = true;
-    this.stdout.off("data", this.handleStdoutData);
-    this.stdin.removeListener("error", this.handleStdinError);
-    for (const [id, pending] of this.pending) {
-      if (pending.timer) {
-        clearTimeout(pending.timer);
-      }
-      pending.reject(new Error(`${reason.message} while waiting for ${pending.method}`));
-      this.pending.delete(id);
-    }
-    this.lineBuffer = "";
-    this.emitter.emit("dispose", reason);
-    this.emitter.removeAllListeners();
-  }
-  handleStdoutData = (chunk) => {
-    this.lineBuffer += chunk.toString();
-    let newlineIndex = this.lineBuffer.indexOf("\n");
-    while (newlineIndex >= 0) {
-      const line = this.lineBuffer.slice(0, newlineIndex).trim();
-      this.lineBuffer = this.lineBuffer.slice(newlineIndex + 1);
-      if (line.length > 0) {
-        this.handleLine(line);
-      }
-      newlineIndex = this.lineBuffer.indexOf("\n");
-    }
-  };
-  handleStdinError = (error) => {
-    this.dispose(new Error(`ASP stdin error: ${error.message}`));
-  };
-  handleLine(line) {
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch (error) {
-      console.warn("[AspClient] Failed to parse ASP JSON line:", error);
-      return;
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      console.warn("[AspClient] Ignoring non-object ASP message");
-      return;
-    }
-    const message = parsed;
-    const hasRequestId = typeof message.id === "number" || typeof message.id === "string";
-    if (hasRequestId && (hasOwn(message, "result") || hasOwn(message, "error"))) {
-      this.handleResponse(message);
-      return;
-    }
-    if (hasRequestId && typeof message.method === "string") {
-      this.emitter.emit("serverRequest", message);
-      return;
-    }
-    if (!hasOwn(message, "id") && typeof message.method === "string") {
-      this.emitter.emit("notification", message);
-    }
-  }
-  handleResponse(message) {
-    if (typeof message.id !== "number") {
-      console.warn("[AspClient] Ignoring response with non-numeric request id");
-      return;
-    }
-    const pending = this.pending.get(message.id);
-    if (!pending) {
-      console.warn(`[AspClient] Ignoring response for unknown request id ${message.id}`);
-      return;
-    }
-    this.pending.delete(message.id);
-    if (pending.timer) {
-      clearTimeout(pending.timer);
-    }
-    if (hasOwn(message, "error")) {
-      pending.reject(this.createRpcError(pending.method, message.error));
-      return;
-    }
-    pending.resolve(message.result);
-  }
-  createRpcError(method, error) {
-    if (typeof error !== "object" || error === null || Array.isArray(error)) {
-      return new Error(`ASP request failed for ${method}`);
-    }
-    const rpcError = error;
-    const code = typeof rpcError.code === "number" ? ` ${rpcError.code}` : "";
-    const message = typeof rpcError.message === "string" ? rpcError.message : "Unknown ASP error";
-    const data = hasOwn(rpcError, "data") ? ` data=${JSON.stringify(rpcError.data)}` : "";
-    return new Error(`ASP request failed for ${method}:${code} ${message}${data}`);
-  }
-  write(message) {
-    try {
-      this.stdin.write(`${JSON.stringify(message)}
-`, (error) => {
-        if (error) {
-          this.dispose(new Error(`ASP write failed: ${error.message}`));
-        }
-      });
-    } catch (error) {
-      const writeError = error instanceof Error ? error : new Error("ASP write failed");
-      this.dispose(writeError);
-      throw writeError;
-    }
-  }
-};
-
-// src/managers/codex-asp/app-server-process.ts
-var DEFAULT_CODEX_BINARY = "codex";
-var DEFAULT_CODEX_ARGS = ["app-server", "--listen", "stdio://"];
-var ENGINE_PACKAGE_VERSION = "0.1.213";
-var INITIALIZE_METHOD = "initialize";
-var INITIALIZED_NOTIFICATION = "initialized";
-var ACCOUNT_LOGIN_START_METHOD = "account/login/start";
-var AppServerProcess = class {
-  binary;
-  args;
-  env;
-  cwd;
-  emitter = new EventEmitter2();
-  child = null;
-  client = null;
-  shuttingDown = false;
-  constructor(options = {}) {
-    this.binary = options.binary ?? DEFAULT_CODEX_BINARY;
-    this.args = options.args ?? DEFAULT_CODEX_ARGS;
-    this.env = options.env ?? buildCodexAgentEnv();
-    this.cwd = options.cwd ?? ENGINE_ENV.WORKSPACE_ROOT;
-  }
-  on(event, listener) {
-    this.emitter.on(event, listener);
-  }
-  async start() {
-    if (this.child && this.client) {
-      return { client: this.client };
-    }
-    this.shuttingDown = false;
-    const child = spawn(this.binary, this.args, {
-      cwd: this.cwd,
-      env: this.env,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    this.child = child;
-    child.stderr.setEncoding("utf8");
-    child.stderr.on("data", (chunk) => {
-      for (const line of chunk.toString().split("\n")) {
-        if (line.trim().length > 0) {
-          console.error(`[codex-app-server] ${line}`);
-        }
-      }
-    });
-    child.on("exit", (code, signal) => {
-      this.client?.dispose();
-      this.client = null;
-      this.child = null;
-      if (!this.shuttingDown) {
-        console.warn(`[AppServerProcess] codex app-server exited unexpectedly code=${code ?? "null"} signal=${signal ?? "null"}`);
-        this.emitter.emit("exit", code, signal);
-      }
-    });
-    const client = new AspClient({ stdin: child.stdin, stdout: child.stdout });
-    this.client = client;
-    let cleanupEarlyFailureHandlers = () => {
-    };
-    const earlyFailure = new Promise((_resolve, reject) => {
-      const onError = (error) => {
-        reject(error);
-      };
-      const onExit = (code, signal) => {
-        reject(new Error(`codex app-server exited before initialize completed code=${code ?? "null"} signal=${signal ?? "null"}`));
-      };
-      child.once("error", onError);
-      child.once("exit", onExit);
-      cleanupEarlyFailureHandlers = () => {
-        child.off("error", onError);
-        child.off("exit", onExit);
-      };
-    });
-    try {
-      const initializeParams = {
-        clientInfo: {
-          name: "replicas_engine",
-          title: "Replicas Engine",
-          version: ENGINE_PACKAGE_VERSION
-        },
-        capabilities: {
-          experimentalApi: true,
-          requestAttestation: false,
-          optOutNotificationMethods: null
-        }
-      };
-      await Promise.race([
-        client.request(INITIALIZE_METHOD, initializeParams),
-        earlyFailure
-      ]);
-      cleanupEarlyFailureHandlers();
-      client.notify(INITIALIZED_NOTIFICATION);
-      await this.loginWithConfiguredApiKey(client);
-      return { client };
-    } catch (error) {
-      cleanupEarlyFailureHandlers();
-      client.dispose();
-      await this.killAfterFailedStart();
-      throw error;
+      cleanupEarlyFailureHandlers();
+      client.dispose();
+      await this.killAfterFailedStart();
+      throw error;
     }
   }
   async stop() {
@@ -6193,807 +5712,1609 @@ async function restartCodexAspHost() {
     if (process2) {
       await process2.stop();
     }
-  })();
-  try {
-    await restartPromise;
-  } finally {
-    restartPromise = null;
+  })();
+  try {
+    await restartPromise;
+  } finally {
+    restartPromise = null;
+  }
+}
+
+// src/utils/codex-quota.ts
+function buildCodexRateLimitsSnapshot(fields) {
+  if (fields.unlimited === true) return null;
+  let state = "ok";
+  if (fields.hasCredits === false) {
+    state = "out_of_credits";
+  } else if (fields.rateLimitResetType !== null) {
+    state = "rate_limited";
+  }
+  return {
+    state,
+    balance: fields.balance,
+    rateLimitResetType: fields.rateLimitResetType,
+    planType: fields.planType
+  };
+}
+function extractCodexRateLimitsSnapshotFromJsonl(parsed) {
+  if (!isRecord4(parsed)) return null;
+  const payload = isRecord4(parsed.payload) ? parsed.payload : parsed;
+  const rateLimits = isRecord4(payload.rate_limits) ? payload.rate_limits : null;
+  if (!rateLimits) return null;
+  const credits = isRecord4(rateLimits.credits) ? rateLimits.credits : null;
+  const hasCredits = credits && typeof credits.has_credits === "boolean" ? credits.has_credits : null;
+  const unlimited = credits && typeof credits.unlimited === "boolean" ? credits.unlimited : null;
+  const balance = credits && typeof credits.balance === "string" ? credits.balance : null;
+  const rateLimitResetType = typeof rateLimits.rate_limit_reached_type === "string" && rateLimits.rate_limit_reached_type.length > 0 ? rateLimits.rate_limit_reached_type : null;
+  const planType = typeof rateLimits.plan_type === "string" ? rateLimits.plan_type : null;
+  return buildCodexRateLimitsSnapshot({
+    unlimited,
+    hasCredits,
+    balance,
+    rateLimitResetType,
+    planType
+  });
+}
+var CodexQuotaStatusTracker = class {
+  lastEmittedQuotaState = "ok";
+  latestQuotaSnapshot = null;
+  quotaBlocked = false;
+  get blocked() {
+    return this.quotaBlocked;
+  }
+  get latestSnapshot() {
+    return this.latestQuotaSnapshot;
+  }
+  prime(snapshot) {
+    this.latestQuotaSnapshot = snapshot;
+    this.quotaBlocked = snapshot.state === "out_of_credits";
+  }
+  apply(snapshot, force = false) {
+    const stateChanged = snapshot.state !== this.lastEmittedQuotaState;
+    if (!stateChanged && !force) {
+      return null;
+    }
+    this.lastEmittedQuotaState = snapshot.state;
+    this.quotaBlocked = snapshot.state === "out_of_credits";
+    this.latestQuotaSnapshot = snapshot;
+    const payload = {
+      state: snapshot.state,
+      balance: snapshot.balance,
+      rateLimitResetType: snapshot.rateLimitResetType,
+      planType: snapshot.planType
+    };
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: CODEX_QUOTA_STATUS_EVENT_TYPE,
+      payload
+    };
+    return event;
+  }
+};
+
+// src/utils/codex-auth.ts
+function isCodexAuthError(error) {
+  const msg = error instanceof Error ? error.message : String(error);
+  const lower = msg.toLowerCase();
+  return lower.includes("unauthorized") || lower.includes("authentication") || lower.includes("invalid api key") || lower.includes("incorrect api key") || lower.includes("api key") && lower.includes("invalid") || lower.includes("401") || lower.includes('codexerrorinfo="unauthorized"') || lower.includes("codexerrorinfo=unauthorized");
+}
+
+// src/managers/codex-asp/mappers.ts
+var DEFAULT_MODEL = "gpt-5.5";
+var THREAD_START_METHOD = "thread/start";
+var THREAD_RESUME_METHOD = "thread/resume";
+var THREAD_READ_METHOD = "thread/read";
+var THREAD_GOAL_SET_METHOD = "thread/goal/set";
+var THREAD_GOAL_GET_METHOD = "thread/goal/get";
+var THREAD_GOAL_CLEAR_METHOD = "thread/goal/clear";
+var TURN_START_METHOD = "turn/start";
+var TURN_INTERRUPT_METHOD = "turn/interrupt";
+var ACCOUNT_RATE_LIMITS_READ_METHOD = "account/rateLimits/read";
+function toReasoningEffort(thinkingLevel) {
+  return codexReasoningEffortForThinkingLevel(thinkingLevel);
+}
+function extractRateLimitsSnapshot(rateLimits) {
+  const credits = rateLimits.credits;
+  return buildCodexRateLimitsSnapshot({
+    unlimited: credits?.unlimited ?? null,
+    hasCredits: credits?.hasCredits ?? null,
+    balance: credits?.balance ?? null,
+    rateLimitResetType: rateLimits.rateLimitReachedType || null,
+    planType: rateLimits.planType
+  });
+}
+function timestampFromSeconds(value) {
+  return new Date((value ?? Date.now() / 1e3) * 1e3).toISOString();
+}
+function timestampFromMilliseconds(value) {
+  return new Date(value ?? Date.now()).toISOString();
+}
+function stringifyToolOutput(value) {
+  if (value === null || value === void 0) return void 0;
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && "content" in value && Array.isArray(value.content)) {
+    const text = value.content.map((item) => {
+      if (typeof item === "string") return item;
+      if (item && typeof item === "object" && "text" in item && typeof item.text === "string") {
+        return item.text;
+      }
+      return "";
+    }).filter(Boolean).join("\n");
+    if (text) return text;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function transcriptPatchOperation(change) {
+  return {
+    action: change.kind.type,
+    path: change.path,
+    ...change.kind.type === "update" && change.kind.move_path ? { moveTo: change.kind.move_path } : {},
+    ...change.diff.trim().length > 0 ? { diff: change.diff } : {}
+  };
+}
+function transcriptItemsForTurn(turn) {
+  const userItems = turn.items.filter((item) => item.type === "userMessage");
+  const otherItems = turn.items.filter((item) => item.type !== "userMessage");
+  return [...userItems, ...otherItems];
+}
+function itemToTranscriptItem(item, timestamp, status) {
+  if (item.type === "userMessage") {
+    const content = item.content.filter((input) => input.type === "text").map((input) => input.text).join("\n");
+    return {
+      type: "userMessage",
+      id: item.id,
+      content,
+      timestamp
+    };
+  }
+  if (item.type === "agentMessage") {
+    return {
+      type: "agentMessage",
+      id: item.id,
+      text: item.text,
+      timestamp
+    };
+  }
+  if (item.type === "reasoning") {
+    return {
+      type: "reasoning",
+      id: item.id,
+      text: [...item.summary, ...item.content].filter(Boolean).join("\n").trim(),
+      timestamp,
+      status
+    };
+  }
+  if (item.type === "commandExecution") {
+    const exitCode = item.exitCode ?? null;
+    return {
+      type: "commandExecution",
+      id: item.id,
+      command: item.command,
+      ...item.aggregatedOutput ? { output: item.aggregatedOutput } : {},
+      exitCode,
+      timestamp,
+      status: normalizeCodexAspTranscriptStatus(item.status, typeof exitCode === "number" && exitCode !== 0)
+    };
+  }
+  if (item.type === "fileChange") {
+    return {
+      type: "fileChange",
+      id: item.id,
+      operations: item.changes.map(transcriptPatchOperation),
+      output: item.status,
+      exitCode: item.status === "completed" ? 0 : 1,
+      timestamp,
+      status: normalizeCodexAspTranscriptStatus(item.status)
+    };
+  }
+  if (item.type === "mcpToolCall") {
+    return {
+      type: "toolCall",
+      id: item.id,
+      server: item.server,
+      tool: item.tool,
+      input: item.arguments,
+      output: item.error?.message ?? stringifyToolOutput(item.result),
+      timestamp,
+      status: normalizeCodexAspTranscriptStatus(item.status, item.status === "failed")
+    };
+  }
+  if (item.type === "dynamicToolCall") {
+    return {
+      type: "toolCall",
+      id: item.id,
+      server: item.namespace ?? "dynamic",
+      tool: item.tool,
+      input: item.arguments,
+      output: stringifyToolOutput(item.contentItems),
+      timestamp,
+      status: normalizeCodexAspTranscriptStatus(item.status, item.success === false)
+    };
+  }
+  if (item.type === "collabAgentToolCall") {
+    return {
+      type: "toolCall",
+      id: item.id,
+      server: "collab",
+      tool: item.tool,
+      input: item.prompt ?? void 0,
+      output: stringifyToolOutput(item.agentsStates),
+      timestamp,
+      status: normalizeCodexAspTranscriptStatus(item.status, item.status === "failed")
+    };
+  }
+  if (item.type === "webSearch") {
+    return {
+      type: "webSearch",
+      id: item.id,
+      query: item.query,
+      timestamp,
+      status
+    };
+  }
+  if (item.type === "plan") {
+    return {
+      type: "plan",
+      id: item.id,
+      text: item.text,
+      timestamp,
+      status
+    };
+  }
+  if (item.type === "contextCompaction") {
+    return {
+      type: "contextCompaction",
+      id: item.id,
+      timestamp,
+      status
+    };
+  }
+  if (item.type === "imageView" || item.type === "imageGeneration" || item.type === "hookPrompt") {
+    return null;
+  }
+  if (item.type === "enteredReviewMode" || item.type === "exitedReviewMode") {
+    return {
+      type: "reasoning",
+      id: item.id,
+      text: item.review,
+      timestamp,
+      status
+    };
+  }
+  return null;
+}
+function aspGoalToChatGoal(goal) {
+  return {
+    threadId: goal.threadId,
+    objective: goal.objective,
+    status: goal.status,
+    tokenBudget: goal.tokenBudget,
+    tokensUsed: goal.tokensUsed,
+    timeUsedSeconds: goal.timeUsedSeconds,
+    createdAt: timestampFromSeconds(goal.createdAt),
+    updatedAt: timestampFromSeconds(goal.updatedAt)
+  };
+}
+function formatTurnFailure(turn) {
+  const turnError = turn.error;
+  if (!turnError) {
+    return "Codex ASP turn failed without error details";
+  }
+  const parts = [`Codex ASP turn failed: ${turnError.message}`];
+  if (turnError.codexErrorInfo !== null) {
+    parts.push(`codexErrorInfo=${JSON.stringify(turnError.codexErrorInfo)}`);
+  }
+  if (turnError.additionalDetails) {
+    parts.push(`details=${turnError.additionalDetails}`);
+  }
+  return parts.join(" ");
+}
+function threadToAspTranscript(thread) {
+  let sequence = 0;
+  const turns = thread.turns.map((turn, index) => ({ turn, index })).sort((a, b) => (a.turn.startedAt ?? a.turn.completedAt ?? Number.MAX_SAFE_INTEGER) - (b.turn.startedAt ?? b.turn.completedAt ?? Number.MAX_SAFE_INTEGER) || a.index - b.index).map(({ turn }) => {
+    const startedAt = timestampFromSeconds(turn.startedAt);
+    const completedAt = turn.completedAt === null ? null : timestampFromSeconds(turn.completedAt);
+    const itemTimestamp = completedAt ?? startedAt;
+    const status = normalizeCodexAspTranscriptStatus(turn.status);
+    const items = [];
+    for (const item of transcriptItemsForTurn(turn)) {
+      const transcriptItem = itemToTranscriptItem(item, item.type === "userMessage" ? startedAt : itemTimestamp, status);
+      if (transcriptItem) {
+        items.push({ ...transcriptItem, sequence: sequence++ });
+      }
+    }
+    if (turn.error) {
+      items.push({
+        type: "error",
+        id: `${turn.id}-error`,
+        message: formatTurnFailure(turn),
+        timestamp: itemTimestamp,
+        sequence: sequence++
+      });
+    }
+    return {
+      id: turn.id,
+      status: turn.status,
+      startedAt,
+      completedAt,
+      items
+    };
+  });
+  return {
+    threadId: thread.id,
+    updatedAt: timestampFromSeconds(thread.updatedAt),
+    turns
+  };
+}
+function latestIsoTimestamp(a, b) {
+  return Date.parse(a) >= Date.parse(b) ? a : b;
+}
+function nextTranscriptSequence(transcript) {
+  let max = -1;
+  for (const turn of transcript.turns) {
+    for (const item of turn.items) {
+      if (typeof item.sequence === "number" && item.sequence > max) {
+        max = item.sequence;
+      }
+    }
+  }
+  return max + 1;
+}
+function transcriptItemRank(item) {
+  return item.type === "userMessage" ? 0 : 1;
+}
+function transcriptItemSignature(item) {
+  if (item.type === "userMessage") return `user:${item.content.trim()}`;
+  if (item.type === "agentMessage" && item.text.trim()) return `agent:${item.text.trim()}`;
+  if (item.type === "plan" && item.text.trim()) return `plan:${item.text.trim()}`;
+  if (item.type === "error" && item.message.trim()) return `error:${item.message.trim()}`;
+  return null;
+}
+function areEquivalentTranscriptItems(current, candidate) {
+  if (current.id === candidate.id) return true;
+  if (current.type !== candidate.type) return false;
+  const signature = transcriptItemSignature(current);
+  return signature !== null && signature === transcriptItemSignature(candidate);
+}
+function findEquivalentCodexAspTranscriptItemIndex(items, candidate) {
+  return items.findIndex((current) => areEquivalentTranscriptItems(current, candidate));
+}
+function sortTranscriptItems(items) {
+  return [...items].map((item, index) => ({ item, index })).sort((a, b) => {
+    const aSequence = a.item.sequence ?? Number.MAX_SAFE_INTEGER;
+    const bSequence = b.item.sequence ?? Number.MAX_SAFE_INTEGER;
+    return transcriptItemRank(a.item) - transcriptItemRank(b.item) || aSequence - bSequence || Date.parse(a.item.timestamp) - Date.parse(b.item.timestamp) || a.index - b.index;
+  }).map(({ item }) => item);
+}
+function dedupeTranscriptItems(items) {
+  const deduped = [];
+  for (const item of items) {
+    const existingIndex = findEquivalentCodexAspTranscriptItemIndex(deduped, item);
+    if (existingIndex === -1) {
+      deduped.push(item);
+      continue;
+    }
+    deduped[existingIndex] = mergeTranscriptItem(deduped[existingIndex], item);
+  }
+  return deduped;
+}
+function normalizeCodexAspTranscriptSequences(transcript) {
+  let sequence = 0;
+  const turns = [...transcript.turns].map((turn, index) => ({ turn, index })).sort((a, b) => Date.parse(a.turn.startedAt) - Date.parse(b.turn.startedAt) || a.index - b.index).map(({ turn }) => ({
+    ...turn,
+    items: sortTranscriptItems(dedupeTranscriptItems(turn.items)).map((item) => ({
+      ...item,
+      sequence: sequence++
+    }))
+  }));
+  return {
+    ...transcript,
+    turns
+  };
+}
+function mergeCodexAspTranscriptItem(current, candidate) {
+  if (current.type === "agentMessage" && candidate.type === "agentMessage" && candidate.text.length === 0) {
+    return {
+      ...current,
+      sequence: current.sequence ?? candidate.sequence
+    };
+  }
+  return {
+    ...current,
+    ...candidate,
+    id: current.id,
+    timestamp: current.timestamp,
+    sequence: current.sequence ?? candidate.sequence
+  };
+}
+function mergeCodexAspTranscripts(primary, supplemental) {
+  if (!primary) return supplemental ? normalizeCodexAspTranscriptSequences(supplemental) : null;
+  if (!supplemental) return normalizeCodexAspTranscriptSequences(primary);
+  if (primary.threadId !== supplemental.threadId) return normalizeCodexAspTranscriptSequences(supplemental);
+  let sequence = nextTranscriptSequence(primary);
+  const turns = primary.turns.map((turn) => ({
+    ...turn,
+    items: [...turn.items]
+  }));
+  for (const supplementalTurn of supplemental.turns) {
+    const existingTurn = turns.find((turn) => turn.id === supplementalTurn.id);
+    if (!existingTurn) {
+      turns.push({
+        ...supplementalTurn,
+        items: supplementalTurn.items.map((item) => typeof item.sequence === "number" ? item : { ...item, sequence: sequence++ })
+      });
+      continue;
+    }
+    existingTurn.status = supplementalTurn.status;
+    existingTurn.completedAt = supplementalTurn.completedAt ?? existingTurn.completedAt;
+    existingTurn.startedAt = Date.parse(existingTurn.startedAt) <= Date.parse(supplementalTurn.startedAt) ? existingTurn.startedAt : supplementalTurn.startedAt;
+    for (const item of supplementalTurn.items) {
+      const existingIndex = findEquivalentCodexAspTranscriptItemIndex(existingTurn.items, item);
+      if (existingIndex === -1) {
+        existingTurn.items.push(
+          typeof item.sequence === "number" ? item : { ...item, sequence: sequence++ }
+        );
+        continue;
+      }
+      existingTurn.items[existingIndex] = mergeCodexAspTranscriptItem(existingTurn.items[existingIndex], item);
+    }
+    existingTurn.items = sortTranscriptItems(existingTurn.items);
+  }
+  return normalizeCodexAspTranscriptSequences({
+    threadId: primary.threadId,
+    updatedAt: latestIsoTimestamp(primary.updatedAt, supplemental.updatedAt),
+    turns: turns.sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt))
+  });
+}
+async function buildThreadStartParams(workingDirectory, request, developerInstructions) {
+  const additionalDirectories = await getAgentAdditionalDirectories();
+  return {
+    model: request.model ?? DEFAULT_MODEL,
+    cwd: workingDirectory,
+    runtimeWorkspaceRoots: additionalDirectories,
+    sandbox: "danger-full-access",
+    developerInstructions: developerInstructions ?? null,
+    config: { web_search: "live" },
+    experimentalRawEvents: false,
+    persistExtendedHistory: false
+  };
+}
+async function buildThreadResumeParams(workingDirectory, threadId, request, developerInstructions) {
+  const additionalDirectories = await getAgentAdditionalDirectories();
+  return {
+    threadId,
+    model: request.model ?? DEFAULT_MODEL,
+    cwd: workingDirectory,
+    runtimeWorkspaceRoots: additionalDirectories,
+    sandbox: "danger-full-access",
+    developerInstructions: developerInstructions ?? null,
+    config: { web_search: "live" },
+    excludeTurns: false,
+    persistExtendedHistory: false
+  };
+}
+async function buildTurnInput(request) {
+  const input = [{
+    type: "text",
+    text: request.message,
+    text_elements: []
+  }];
+  if (!request.images || request.images.length === 0) {
+    return { input, tempImagePaths: [] };
+  }
+  const normalizedImages = await normalizeImages(request.images);
+  const tempImagePaths = await saveNormalizedImagesToTempFiles(normalizedImages);
+  input.push(...tempImagePaths.map((path4) => ({
+    type: "localImage",
+    path: path4
+  })));
+  return { input, tempImagePaths };
+}
+async function buildTurnStartParams(threadId, request, developerInstructions) {
+  const effort = toReasoningEffort(request.thinkingLevel);
+  const model = request.model ?? DEFAULT_MODEL;
+  const { input, tempImagePaths } = await buildTurnInput(request);
+  return {
+    params: {
+      threadId,
+      input,
+      model,
+      ...effort ? { effort } : {},
+      ...developerInstructions ? {
+        collaborationMode: {
+          mode: "default",
+          settings: {
+            model,
+            reasoning_effort: effort ?? null,
+            developer_instructions: developerInstructions
+          }
+        }
+      } : {}
+    },
+    tempImagePaths
+  };
+}
+
+// src/managers/codex-asp/notification-dispatch.ts
+var TURN_STARTED_METHOD = "turn/started";
+var TURN_COMPLETED_METHOD = "turn/completed";
+var TURN_PLAN_UPDATED_METHOD = "turn/plan/updated";
+var THREAD_GOAL_UPDATED_METHOD = "thread/goal/updated";
+var THREAD_GOAL_CLEARED_METHOD = "thread/goal/cleared";
+var ITEM_STARTED_METHOD = "item/started";
+var ITEM_COMPLETED_METHOD = "item/completed";
+var AGENT_MESSAGE_DELTA_METHOD = "item/agentMessage/delta";
+var COMMAND_EXECUTION_OUTPUT_DELTA_METHOD = "item/commandExecution/outputDelta";
+var FILE_CHANGE_OUTPUT_DELTA_METHOD = "item/fileChange/outputDelta";
+var ACCOUNT_RATE_LIMITS_UPDATED_METHOD = "account/rateLimits/updated";
+var THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated";
+var THREAD_COMPACTED_METHOD = "thread/compacted";
+var COMMAND_APPROVAL_METHOD = "item/commandExecution/requestApproval";
+var FILE_CHANGE_APPROVAL_METHOD = "item/fileChange/requestApproval";
+function dispatchAspNotification(notification, handlers) {
+  const handler = handlers[notification.method];
+  if (!handler) return;
+  handler(notification);
+}
+
+// src/managers/codex-asp/codex-asp-manager.ts
+var CodexAspManager = class extends CodingAgentManager {
+  currentThreadId = null;
+  activeTurnId = null;
+  threadAttached = false;
+  historyEvents = [];
+  codexAspTranscript = null;
+  codexAspSequence = 0;
+  quotaStatus = new CodexQuotaStatusTracker();
+  currentGoal = null;
+  constructor(options) {
+    super(options);
+    this.initializeManager(this.processMessageInternal.bind(this));
+  }
+  async initialize() {
+    if (this.initialSessionId) {
+      this.currentThreadId = this.initialSessionId;
+    }
+  }
+  async interruptActiveTurn() {
+    if (!this.currentThreadId || !this.activeTurnId) {
+      return;
+    }
+    try {
+      const host = await getCodexAspHost();
+      const params = {
+        threadId: this.currentThreadId,
+        turnId: this.activeTurnId
+      };
+      await host.client.request(TURN_INTERRUPT_METHOD, params);
+    } catch (error) {
+      console.warn("[CodexAspManager] Failed to interrupt active turn:", error);
+    }
+  }
+  async getHistory() {
+    if (!this.currentThreadId) {
+      return { thread_id: null, events: [], goal: null };
+    }
+    if (this.activeTurnId && this.codexAspTranscript?.threadId === this.currentThreadId) {
+      try {
+        const host = await getCodexAspHost();
+        await this.refreshThreadGoal(host, this.currentThreadId);
+      } catch {
+      }
+      return {
+        thread_id: this.currentThreadId,
+        events: [...this.historyEvents],
+        codexAspTranscript: this.codexAspTranscript,
+        goal: this.currentGoal
+      };
+    }
+    try {
+      const host = await getCodexAspHost();
+      const [response] = await Promise.all([
+        host.client.request(
+          THREAD_READ_METHOD,
+          { threadId: this.currentThreadId, includeTurns: true }
+        ),
+        this.refreshThreadGoal(host, this.currentThreadId)
+      ]);
+      const transcript = this.mergeTranscriptSnapshot(threadToAspTranscript(response.thread));
+      if (transcript) {
+        transcript.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return {
+        thread_id: this.currentThreadId,
+        events: [...this.historyEvents],
+        codexAspTranscript: transcript,
+        goal: this.currentGoal
+      };
+    } catch {
+    }
+    return {
+      thread_id: this.currentThreadId,
+      events: [...this.historyEvents],
+      codexAspTranscript: this.codexAspTranscript,
+      goal: this.currentGoal
+    };
+  }
+  getGoal() {
+    return this.currentGoal;
+  }
+  async clearGoal() {
+    await this.initialized;
+    if (!this.currentThreadId) {
+      this.recordGoalChange(null, true);
+      return null;
+    }
+    const host = await getCodexAspHost();
+    await host.client.request(
+      THREAD_GOAL_CLEAR_METHOD,
+      { threadId: this.currentThreadId }
+    );
+    this.recordGoalChange(null, true);
+    return null;
+  }
+  async processMessageInternal(request) {
+    let userMessageRecorded = false;
+    const recordUserMessage = (extraPayload = {}) => {
+      if (userMessageRecorded) return;
+      userMessageRecorded = true;
+      this.recordHistoryEvent("event_msg", {
+        type: "user_message",
+        message: request.message,
+        ...extraPayload
+      });
+    };
+    const goalCommand = parseGoalCommand(request.message);
+    const dispatch = async () => {
+      if (goalCommand?.type === "clear") {
+        await this.executeGoalClearCommand(request, recordUserMessage);
+        return;
+      }
+      if (goalCommand?.type === "set") {
+        await this.executeAspTurn(request, recordUserMessage, {
+          runTurn: (host, threadId) => this.runGoalTurn(host, threadId, request, goalCommand.objective),
+          userMessagePayload: { command: "goal" }
+        });
+        return;
+      }
+      await this.executeAspTurn(request, recordUserMessage);
+    };
+    try {
+      await dispatch();
+    } catch (error) {
+      if (isCodexAuthError(error)) {
+        const refreshed = await codexTokenManager.fetchFreshCredentials(error instanceof Error ? error.message : String(error));
+        if (refreshed) {
+          await restartCodexAspHost();
+          this.threadAttached = false;
+          await dispatch();
+          return;
+        }
+      }
+      throw error;
+    } finally {
+      this.activeTurnId = null;
+      await this.onTurnComplete();
+    }
+  }
+  async executeGoalClearCommand(request, recordUserMessage) {
+    const host = await getCodexAspHost();
+    const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
+    recordUserMessage({ command: "goal" });
+    const threadId = await this.ensureThread(host, request, developerInstructions);
+    await host.client.request(
+      THREAD_GOAL_CLEAR_METHOD,
+      { threadId }
+    );
+    this.recordGoalChange(null, true);
+  }
+  async executeAspTurn(request, recordUserMessage, options = {}) {
+    const host = await getCodexAspHost();
+    if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
+      await this.refreshQuotaSnapshot(host);
+      if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
+        recordUserMessage(options.userMessagePayload);
+        this.emitQuotaStatus(this.quotaStatus.latestSnapshot, true);
+        return;
+      }
+    }
+    const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
+    recordUserMessage(options.userMessagePayload);
+    const threadId = await this.ensureThread(host, request, developerInstructions);
+    const runTurn = options.runTurn ?? ((aspHost, aspThreadId, aspInstructions) => this.runTurn(aspHost, aspThreadId, request, aspInstructions));
+    let completedTurn;
+    try {
+      completedTurn = await runTurn(host, threadId, developerInstructions);
+    } catch (error) {
+      await this.refreshQuotaSnapshot(host);
+      if (this.quotaStatus.blocked) {
+        return;
+      }
+      throw error;
+    }
+    if (completedTurn.status === "failed") {
+      await this.refreshQuotaSnapshot(host);
+      if (this.quotaStatus.blocked) {
+        return;
+      }
+      throw new Error(formatTurnFailure(completedTurn));
+    }
+  }
+  async ensureThread(host, request, developerInstructions) {
+    const existingThreadId = this.currentThreadId;
+    if (existingThreadId) {
+      if (!this.threadAttached) {
+        const response = await host.client.request(
+          THREAD_RESUME_METHOD,
+          await buildThreadResumeParams(this.workingDirectory, existingThreadId, request, developerInstructions)
+        );
+        this.currentThreadId = response.thread.id;
+        this.threadAttached = true;
+        this.seedHistoryFromThread(response.thread);
+        await this.onSaveSessionId(this.currentThreadId);
+      }
+      return this.currentThreadId ?? existingThreadId;
+    }
+    const threadStartResponse = await host.client.request(
+      THREAD_START_METHOD,
+      await buildThreadStartParams(this.workingDirectory, request, developerInstructions)
+    );
+    const threadId = threadStartResponse.thread.id;
+    this.currentThreadId = threadId;
+    this.threadAttached = true;
+    await this.onSaveSessionId(this.currentThreadId);
+    return threadId;
+  }
+  async runTurn(host, threadId, request, developerInstructions) {
+    const { params, tempImagePaths } = await buildTurnStartParams(threadId, request, developerInstructions);
+    return this.observeTurn(host, threadId, request, async () => {
+      const turnStartResponse = await host.client.request(
+        TURN_START_METHOD,
+        params
+      );
+      return { turn: turnStartResponse.turn, tempImagePaths };
+    });
+  }
+  async runGoalTurn(host, threadId, request, objective) {
+    return this.observeTurn(host, threadId, request, async () => {
+      const response = await host.client.request(
+        THREAD_GOAL_SET_METHOD,
+        { threadId, objective, status: "active" }
+      );
+      this.recordGoalChange(response.goal, true);
+      return { turn: null, tempImagePaths: [] };
+    });
+  }
+  async observeTurn(host, threadId, request, startTurn) {
+    let resolveCompleted;
+    const completed = new Promise((resolve3) => {
+      resolveCompleted = resolve3;
+    });
+    let rejectDisposed = () => {
+    };
+    const disposed = new Promise((_resolve, reject) => {
+      rejectDisposed = reject;
+    });
+    void disposed.catch(() => {
+    });
+    let observedTurnId = null;
+    const completedItems = [];
+    const agentMessageDeltas = /* @__PURE__ */ new Map();
+    const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
+    const model = request.model ?? DEFAULT_MODEL;
+    let tempImagePaths = [];
+    const linearForwarder = new LinearEventForwarder(linearSessionId);
+    const matchesTurn = (notificationThreadId, notificationTurnId) => notificationThreadId === threadId && (!observedTurnId || notificationTurnId === null || notificationTurnId === observedTurnId);
+    const handlers = {
+      [ACCOUNT_RATE_LIMITS_UPDATED_METHOD]: (notification) => {
+        this.handleRateLimits(notification.params.rateLimits);
+      },
+      [THREAD_TOKEN_USAGE_UPDATED_METHOD]: (notification) => {
+        if (notification.params.threadId !== threadId) return;
+        this.emitCodexTokenUsage(notification.params.tokenUsage, model);
+      },
+      [THREAD_GOAL_UPDATED_METHOD]: (notification) => {
+        if (notification.params.threadId !== threadId) return;
+        this.recordGoalChange(notification.params.goal);
+      },
+      [THREAD_GOAL_CLEARED_METHOD]: (notification) => {
+        if (notification.params.threadId !== threadId) return;
+        this.recordGoalChange(null);
+      },
+      [THREAD_COMPACTED_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        this.setCompacting(false);
+      },
+      [TURN_STARTED_METHOD]: (notification) => {
+        if (notification.params.threadId !== threadId) return;
+        observedTurnId = notification.params.turn.id;
+        this.activeTurnId = notification.params.turn.id;
+        this.mergeTranscriptTurn(notification.params.threadId, notification.params.turn);
+        this.emitTranscriptUpdated(notification.params.threadId);
+        linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
+      },
+      [TURN_PLAN_UPDATED_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        this.emitTranscriptUpdated(notification.params.threadId);
+        linearForwarder.sendPlan(extractPlanFromCodexAspNotification(notification));
+      },
+      [ITEM_STARTED_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        if (notification.params.item.type === "contextCompaction") {
+          this.setCompacting(true);
+        }
+        this.upsertTranscriptItem(
+          notification.params.threadId,
+          notification.params.turnId,
+          notification.params.item,
+          timestampFromMilliseconds(notification.params.startedAtMs),
+          "in_progress",
+          "started"
+        );
+        this.emitTranscriptUpdated(notification.params.threadId);
+        linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
+      },
+      [ITEM_COMPLETED_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        completedItems.push(notification.params.item);
+        if (notification.params.item.type === "contextCompaction") {
+          this.setCompacting(false);
+        }
+        const itemFailed = notification.params.item.type === "commandExecution" && typeof notification.params.item.exitCode === "number" && notification.params.item.exitCode !== 0;
+        this.upsertTranscriptItem(
+          notification.params.threadId,
+          notification.params.turnId,
+          notification.params.item,
+          timestampFromMilliseconds(notification.params.completedAtMs),
+          itemFailed ? "failed" : "completed",
+          "completed"
+        );
+        this.emitTranscriptUpdated(notification.params.threadId);
+        linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
+      },
+      [AGENT_MESSAGE_DELTA_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        const currentText = agentMessageDeltas.get(notification.params.itemId) ?? "";
+        agentMessageDeltas.set(notification.params.itemId, currentText + notification.params.delta);
+        this.appendAgentMessageDelta(
+          notification.params.threadId,
+          notification.params.turnId,
+          notification.params.itemId,
+          notification.params.delta
+        );
+        this.emitTranscriptUpdated(notification.params.threadId);
+      },
+      [COMMAND_EXECUTION_OUTPUT_DELTA_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        this.appendTranscriptOutput(notification.params.turnId, notification.params.itemId, notification.params.delta);
+        this.emitTranscriptUpdated(notification.params.threadId);
+      },
+      [FILE_CHANGE_OUTPUT_DELTA_METHOD]: (notification) => {
+        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
+        this.appendTranscriptOutput(notification.params.turnId, notification.params.itemId, notification.params.delta);
+        this.emitTranscriptUpdated(notification.params.threadId);
+      },
+      [TURN_COMPLETED_METHOD]: (notification) => {
+        if (notification.params.threadId !== threadId) return;
+        observedTurnId = notification.params.turn.id;
+        const turn = notification.params.turn;
+        const items = turn.items.length > 0 ? [...turn.items] : [];
+        const itemIds = new Set(items.map((item) => item.id));
+        for (const item of completedItems) {
+          if (!itemIds.has(item.id)) {
+            items.push(item);
+            itemIds.add(item.id);
+          }
+        }
+        for (const [itemId, text] of agentMessageDeltas) {
+          if (!itemIds.has(itemId)) {
+            items.push({
+              type: "agentMessage",
+              id: itemId,
+              text,
+              phase: null,
+              memoryCitation: null
+            });
+          }
+        }
+        const completedTurn = items.length > 0 ? { ...turn, items, itemsView: "full" } : turn;
+        this.mergeTranscriptTurn(notification.params.threadId, completedTurn);
+        this.emitTranscriptUpdated(notification.params.threadId);
+        resolveCompleted(completedTurn);
+      }
+    };
+    const onNotification = (notification) => {
+      dispatchAspNotification(notification, handlers);
+    };
+    const onServerRequest = (serverRequest) => {
+      if (serverRequest.method !== COMMAND_APPROVAL_METHOD && serverRequest.method !== FILE_CHANGE_APPROVAL_METHOD) {
+        return;
+      }
+      console.warn("[CodexAspManager] approval requested while sandbox is danger-full-access");
+      host.client.respond(serverRequest.id, { decision: "accept" });
+    };
+    const onDispose = (reason) => {
+      this.threadAttached = false;
+      this.activeTurnId = null;
+      const turnLabel = observedTurnId ? ` ${observedTurnId}` : "";
+      rejectDisposed(new Error(`Codex ASP client disposed before turn${turnLabel} completed: ${reason.message}`));
+    };
+    host.client.on("notification", onNotification);
+    host.client.on("serverRequest", onServerRequest);
+    host.client.on("dispose", onDispose);
+    try {
+      const started = await startTurn();
+      tempImagePaths = started.tempImagePaths;
+      if (started.turn) {
+        observedTurnId = started.turn.id;
+        this.activeTurnId = started.turn.id;
+      }
+      const turn = await Promise.race([completed, disposed]);
+      linearForwarder.flushThoughtAsResponse();
+      return turn;
+    } finally {
+      host.client.off("notification", onNotification);
+      host.client.off("serverRequest", onServerRequest);
+      host.client.off("dispose", onDispose);
+      await removeTempImageFiles(tempImagePaths);
+      if (host.client.isDisposed) {
+        this.threadAttached = false;
+      }
+    }
+  }
+  nextTranscriptSequence() {
+    return this.codexAspSequence++;
+  }
+  syncTranscriptSequence(transcript) {
+    if (!transcript) return;
+    let next = 0;
+    for (const turn of transcript.turns) {
+      for (const item of turn.items) {
+        if (typeof item.sequence === "number" && item.sequence >= next) {
+          next = item.sequence + 1;
+        }
+      }
+    }
+    this.codexAspSequence = next;
   }
-}
-
-// src/managers/codex-asp/mappers.ts
-var DEFAULT_MODEL2 = "gpt-5.5";
-var THREAD_START_METHOD = "thread/start";
-var THREAD_RESUME_METHOD = "thread/resume";
-var THREAD_READ_METHOD = "thread/read";
-var THREAD_GOAL_SET_METHOD = "thread/goal/set";
-var THREAD_GOAL_GET_METHOD = "thread/goal/get";
-var THREAD_GOAL_CLEAR_METHOD = "thread/goal/clear";
-var TURN_START_METHOD = "turn/start";
-var TURN_INTERRUPT_METHOD = "turn/interrupt";
-var ACCOUNT_RATE_LIMITS_READ_METHOD = "account/rateLimits/read";
-function toReasoningEffort(thinkingLevel) {
-  return codexReasoningEffortForThinkingLevel(thinkingLevel);
-}
-function extractRateLimitsSnapshot(rateLimits) {
-  const credits = rateLimits.credits;
-  return buildCodexRateLimitsSnapshot({
-    unlimited: credits?.unlimited ?? null,
-    hasCredits: credits?.hasCredits ?? null,
-    balance: credits?.balance ?? null,
-    rateLimitResetType: rateLimits.rateLimitReachedType || null,
-    planType: rateLimits.planType
-  });
-}
-function timestampFromSeconds(value) {
-  return new Date((value ?? Date.now() / 1e3) * 1e3).toISOString();
-}
-function aspGoalToChatGoal(goal) {
-  return {
-    threadId: goal.threadId,
-    objective: goal.objective,
-    status: goal.status,
-    tokenBudget: goal.tokenBudget,
-    tokensUsed: goal.tokensUsed,
-    timeUsedSeconds: goal.timeUsedSeconds,
-    createdAt: timestampFromSeconds(goal.createdAt),
-    updatedAt: timestampFromSeconds(goal.updatedAt)
-  };
-}
-function formatTurnFailure(turn) {
-  const turnError = turn.error;
-  if (!turnError) {
-    return "Codex ASP turn failed without error details";
+  mergeTranscriptSnapshot(snapshot) {
+    this.codexAspTranscript = mergeCodexAspTranscripts(this.codexAspTranscript, snapshot);
+    this.syncTranscriptSequence(this.codexAspTranscript);
+    return this.codexAspTranscript;
   }
-  const parts = [`Codex ASP turn failed: ${turnError.message}`];
-  if (turnError.codexErrorInfo !== null) {
-    parts.push(`codexErrorInfo=${JSON.stringify(turnError.codexErrorInfo)}`);
+  ensureTranscript(threadId) {
+    if (this.codexAspTranscript?.threadId === threadId) {
+      return this.codexAspTranscript;
+    }
+    this.codexAspTranscript = {
+      threadId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      turns: []
+    };
+    this.codexAspSequence = 0;
+    return this.codexAspTranscript;
+  }
+  ensureTranscriptTurn(threadId, turnId, startedAt) {
+    const transcript = this.ensureTranscript(threadId);
+    let turn = transcript.turns.find((candidate) => candidate.id === turnId);
+    if (!turn) {
+      turn = {
+        id: turnId,
+        status: "inProgress",
+        startedAt,
+        completedAt: null,
+        items: []
+      };
+      transcript.turns.push(turn);
+      transcript.turns.sort((a, b) => Date.parse(a.startedAt) - Date.parse(b.startedAt));
+      return turn;
+    }
+    if (Date.parse(startedAt) < Date.parse(turn.startedAt)) {
+      turn.startedAt = startedAt;
+    }
+    return turn;
   }
-  if (turnError.additionalDetails) {
-    parts.push(`details=${turnError.additionalDetails}`);
+  mergeTranscriptTurn(threadId, turn) {
+    const startedAt = timestampFromSeconds(turn.startedAt);
+    const completedAt = turn.completedAt === null ? null : timestampFromSeconds(turn.completedAt);
+    const itemTimestamp = completedAt ?? startedAt;
+    const transcriptTurn = this.ensureTranscriptTurn(threadId, turn.id, startedAt);
+    transcriptTurn.status = turn.status;
+    transcriptTurn.completedAt = completedAt;
+    const itemStatus = turn.status === "failed" ? "failed" : turn.status === "completed" ? "completed" : "in_progress";
+    for (const item of turn.items) {
+      this.upsertTranscriptItem(
+        threadId,
+        turn.id,
+        item,
+        item.type === "userMessage" ? startedAt : itemTimestamp,
+        itemStatus,
+        "completed"
+      );
+    }
+    if (turn.error) {
+      const existingIndex = transcriptTurn.items.findIndex((item) => item.id === `${turn.id}-error`);
+      const errorItem = {
+        type: "error",
+        id: `${turn.id}-error`,
+        message: formatTurnFailure(turn),
+        timestamp: itemTimestamp,
+        sequence: existingIndex === -1 ? this.nextTranscriptSequence() : transcriptTurn.items[existingIndex].sequence
+      };
+      if (existingIndex === -1) {
+        transcriptTurn.items.push(errorItem);
+      } else {
+        transcriptTurn.items[existingIndex] = errorItem;
+      }
+    }
+    if (this.codexAspTranscript) {
+      this.codexAspTranscript.updatedAt = itemTimestamp;
+    }
   }
-  return parts.join(" ");
-}
-function formatCommandOutput(item) {
-  const exitCode = item.exitCode ?? (item.status === "completed" ? 0 : 1);
-  const output = item.aggregatedOutput ?? "";
-  return output ? `Exit code: ${exitCode}
-${output}` : `Exit code: ${exitCode}`;
-}
-function fileChangeToPatchInput(item) {
-  const lines = ["*** Begin Patch"];
-  for (const change of item.changes) {
-    if (change.kind.type === "add") {
-      lines.push(`*** Add File: ${change.path}`);
-    } else if (change.kind.type === "delete") {
-      lines.push(`*** Delete File: ${change.path}`);
+  upsertTranscriptItem(threadId, turnId, item, timestamp, status, lifecycle) {
+    const turn = this.ensureTranscriptTurn(threadId, turnId, timestamp);
+    const candidate = itemToTranscriptItem(item, timestamp, status);
+    if (!candidate) return;
+    const existingIndex = findEquivalentCodexAspTranscriptItemIndex(turn.items, candidate);
+    const existing = existingIndex === -1 ? null : turn.items[existingIndex];
+    const sequence = existing?.sequence ?? this.nextTranscriptSequence();
+    const itemTimestamp = existing && lifecycle === "completed" ? existing.timestamp : timestamp;
+    const transcriptItem = itemToTranscriptItem(item, itemTimestamp, status);
+    if (!transcriptItem) return;
+    const sequencedItem = { ...transcriptItem, sequence };
+    if (existingIndex === -1) {
+      turn.items.push(sequencedItem);
     } else {
-      lines.push(`*** Update File: ${change.path}`);
-      if (change.kind.move_path) {
-        lines.push(`*** Move to: ${change.kind.move_path}`);
-      }
+      const existingItem = turn.items[existingIndex];
+      const mergedItem = mergeCodexAspTranscriptItem(existingItem, {
+        ...sequencedItem,
+        timestamp: itemTimestamp,
+        sequence
+      });
+      turn.items[existingIndex] = existingItem.type === "agentMessage" && mergedItem.type === "agentMessage" && lifecycle === "started" && mergedItem.text.length === 0 ? { ...mergedItem, text: existingItem.text } : mergedItem;
     }
-    if (change.diff.trim().length > 0) {
-      lines.push(change.diff);
+    if (this.codexAspTranscript) {
+      this.codexAspTranscript.updatedAt = timestamp;
     }
   }
-  lines.push("*** End Patch");
-  return lines.join("\n");
-}
-function itemToAgentEventDrafts(item, lifecycle) {
-  if (item.type === "agentMessage") {
-    if (lifecycle !== "completed" || !item.text) return [];
-    return [{
-      type: "response_item",
-      payload: {
-        type: "message",
-        role: "assistant",
-        content: [{
-          type: "output_text",
-          text: item.text
-        }]
+  appendAgentMessageDelta(threadId, turnId, itemId, delta) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const turn = this.ensureTranscriptTurn(threadId, turnId, timestamp);
+    const existingIndex = turn.items.findIndex((item) => item.id === itemId);
+    if (existingIndex === -1) {
+      turn.items.push({
+        type: "agentMessage",
+        id: itemId,
+        text: delta,
+        timestamp,
+        sequence: this.nextTranscriptSequence()
+      });
+    } else {
+      const existing = turn.items[existingIndex];
+      if (existing.type === "agentMessage") {
+        turn.items[existingIndex] = {
+          ...existing,
+          text: `${existing.text}${delta}`
+        };
       }
-    }];
+    }
+    if (this.codexAspTranscript) {
+      this.codexAspTranscript.updatedAt = timestamp;
+    }
   }
-  if (item.type === "reasoning") {
-    if (lifecycle !== "completed") return [];
-    const text = [...item.summary, ...item.content].filter(Boolean).join("\n").trim();
-    if (!text) return [];
-    return [{
-      type: "event_msg",
-      payload: {
-        type: "agent_reasoning",
-        text
-      }
-    }];
+  appendTranscriptOutput(turnId, itemId, delta) {
+    if (!this.codexAspTranscript) return;
+    const turn = this.codexAspTranscript.turns.find((candidate) => candidate.id === turnId);
+    if (!turn) return;
+    const itemIndex = turn.items.findIndex((item2) => item2.id === itemId);
+    if (itemIndex === -1) return;
+    const item = turn.items[itemIndex];
+    if (item.type !== "commandExecution" && item.type !== "fileChange") return;
+    turn.items[itemIndex] = {
+      ...item,
+      output: `${item.output ?? ""}${delta}`,
+      status: "in_progress"
+    };
+    this.codexAspTranscript.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   }
-  if (item.type === "commandExecution") {
-    if (lifecycle === "started") {
-      return [{
-        type: "response_item",
-        payload: {
-          type: "function_call",
-          name: "exec_command",
-          call_id: item.id,
-          arguments: JSON.stringify({ cmd: item.command })
-        }
-      }];
-    }
-    return [{
-      type: "response_item",
-      payload: {
-        type: "function_call_output",
-        call_id: item.id,
-        output: formatCommandOutput(item)
-      }
-    }];
+  seedHistoryFromThread(thread) {
+    this.mergeTranscriptSnapshot(threadToAspTranscript(thread));
   }
-  if (item.type === "fileChange") {
-    if (lifecycle === "started") {
-      return [{
-        type: "response_item",
-        payload: {
-          type: "custom_tool_call",
-          name: "apply_patch",
-          call_id: item.id,
-          input: fileChangeToPatchInput(item),
-          status: "in_progress"
-        }
-      }];
+  async refreshThreadGoal(host, threadId) {
+    try {
+      const response = await host.client.request(
+        THREAD_GOAL_GET_METHOD,
+        { threadId }
+      );
+      this.currentGoal = response.goal ? aspGoalToChatGoal(response.goal) : null;
+    } catch (error) {
+      console.warn("[CodexAspManager] Failed to read ASP thread goal:", error);
     }
-    return [{
-      type: "response_item",
-      payload: {
-        type: "custom_tool_call_output",
-        call_id: item.id,
-        output: JSON.stringify({
-          output: item.status,
-          metadata: { exit_code: item.status === "completed" ? 0 : 1 }
-        })
-      }
-    }];
   }
-  if (item.type === "mcpToolCall" || item.type === "dynamicToolCall" || item.type === "webSearch") {
-    const tool2 = item.type === "webSearch" ? "web_search" : item.tool;
-    const input = item.type === "webSearch" ? item.query : JSON.stringify(item.arguments);
-    if (lifecycle === "started") {
-      return [{
-        type: "response_item",
-        payload: {
-          type: "custom_tool_call",
-          name: tool2,
-          call_id: item.id,
-          input,
-          status: "in_progress"
-        }
-      }];
+  recordGoalChange(goal, force = false) {
+    const nextGoal = goal ? aspGoalToChatGoal(goal) : null;
+    if (!force && JSON.stringify(this.currentGoal) === JSON.stringify(nextGoal)) {
+      return;
     }
-    const failed = item.type === "mcpToolCall" && item.status === "failed" || item.type === "dynamicToolCall" && item.success === false;
-    return [{
-      type: "response_item",
-      payload: {
-        type: "custom_tool_call_output",
-        call_id: item.id,
-        output: JSON.stringify({
-          output: failed ? "Failed" : "Done",
-          metadata: { exit_code: failed ? 1 : 0 }
-        })
-      }
-    }];
+    this.currentGoal = nextGoal;
+    const event = this.recordHistoryEvent(
+      CHAT_GOAL_EVENT_TYPE,
+      { goal: nextGoal }
+    );
+    this.onEvent(event);
   }
-  return [];
-}
-function threadToHistoryEvents(thread) {
-  const events = [];
-  const turns = thread.turns.map((turn, index) => ({ turn, index })).sort((a, b) => (a.turn.startedAt ?? a.turn.completedAt ?? Number.MAX_SAFE_INTEGER) - (b.turn.startedAt ?? b.turn.completedAt ?? Number.MAX_SAFE_INTEGER) || a.index - b.index);
-  for (const { turn } of turns) {
-    const startedAt = timestampFromSeconds(turn.startedAt);
-    const completedAt = timestampFromSeconds(turn.completedAt ?? turn.startedAt);
-    const userMessages = turn.items.filter((item) => item.type === "userMessage");
-    const agentItems = turn.items.filter((item) => item.type !== "userMessage");
-    for (const item of userMessages) {
-      const message = item.content.filter((input) => input.type === "text").map((input) => input.text).join("\n");
-      if (message) {
-        events.push({
-          timestamp: startedAt,
-          type: "event_msg",
-          payload: {
-            type: "user_message",
-            message,
-            [CODEX_ASP_ITEM_ID_PAYLOAD_KEY]: item.id
-          }
-        });
-      }
-    }
-    for (const item of agentItems) {
-      for (const draft of itemToAgentEventDrafts(item, "started")) {
-        events.push({ timestamp: startedAt, ...draft });
-      }
-      for (const draft of itemToAgentEventDrafts(item, "completed")) {
-        events.push({ timestamp: completedAt, ...draft });
-      }
-    }
+  recordHistoryEvent(type, payload) {
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      payload
+    };
+    this.historyEvents.push(event);
+    return event;
   }
-  return events;
-}
-async function buildThreadStartParams(workingDirectory, request, developerInstructions) {
-  const additionalDirectories = await getAgentAdditionalDirectories();
-  return {
-    model: request.model ?? DEFAULT_MODEL2,
-    cwd: workingDirectory,
-    runtimeWorkspaceRoots: additionalDirectories,
-    sandbox: "danger-full-access",
-    developerInstructions: developerInstructions ?? null,
-    config: { web_search: "live" },
-    experimentalRawEvents: false,
-    persistExtendedHistory: false
-  };
-}
-async function buildThreadResumeParams(workingDirectory, threadId, request, developerInstructions) {
-  const additionalDirectories = await getAgentAdditionalDirectories();
-  return {
-    threadId,
-    model: request.model ?? DEFAULT_MODEL2,
-    cwd: workingDirectory,
-    runtimeWorkspaceRoots: additionalDirectories,
-    sandbox: "danger-full-access",
-    developerInstructions: developerInstructions ?? null,
-    config: { web_search: "live" },
-    excludeTurns: false,
-    persistExtendedHistory: false
-  };
-}
-async function buildTurnInput(request) {
-  const input = [{
-    type: "text",
-    text: request.message,
-    text_elements: []
-  }];
-  if (!request.images || request.images.length === 0) {
-    return { input, tempImagePaths: [] };
+  emitTranscriptUpdated(threadId) {
+    const updatedAt = this.codexAspTranscript?.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+    const transcript = this.codexAspTranscript ? structuredClone(this.codexAspTranscript) : null;
+    const updatePayload = {
+      updatedAt,
+      transcript,
+      threadId
+    };
+    this.onEvent({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE,
+      payload: updatePayload
+    });
   }
-  const normalizedImages = await normalizeImages(request.images);
-  const tempImagePaths = await saveNormalizedImagesToTempFiles(normalizedImages);
-  input.push(...tempImagePaths.map((path4) => ({
-    type: "localImage",
-    path: path4
-  })));
-  return { input, tempImagePaths };
-}
-async function buildTurnStartParams(threadId, request, developerInstructions) {
-  const effort = toReasoningEffort(request.thinkingLevel);
-  const model = request.model ?? DEFAULT_MODEL2;
-  const { input, tempImagePaths } = await buildTurnInput(request);
-  return {
-    params: {
-      threadId,
-      input,
-      model,
-      ...effort ? { effort } : {},
-      ...developerInstructions ? {
-        collaborationMode: {
-          mode: "default",
-          settings: {
-            model,
-            reasoning_effort: effort ?? null,
-            developer_instructions: developerInstructions
-          }
-        }
-      } : {}
-    },
-    tempImagePaths
-  };
-}
-
-// src/managers/codex-asp/notification-dispatch.ts
-var TURN_STARTED_METHOD = "turn/started";
-var TURN_COMPLETED_METHOD = "turn/completed";
-var TURN_PLAN_UPDATED_METHOD = "turn/plan/updated";
-var THREAD_GOAL_UPDATED_METHOD = "thread/goal/updated";
-var THREAD_GOAL_CLEARED_METHOD = "thread/goal/cleared";
-var ITEM_STARTED_METHOD = "item/started";
-var ITEM_COMPLETED_METHOD = "item/completed";
-var AGENT_MESSAGE_DELTA_METHOD = "item/agentMessage/delta";
-var ACCOUNT_RATE_LIMITS_UPDATED_METHOD = "account/rateLimits/updated";
-var THREAD_TOKEN_USAGE_UPDATED_METHOD = "thread/tokenUsage/updated";
-var THREAD_COMPACTED_METHOD = "thread/compacted";
-var COMMAND_APPROVAL_METHOD = "item/commandExecution/requestApproval";
-var FILE_CHANGE_APPROVAL_METHOD = "item/fileChange/requestApproval";
-function dispatchAspNotification(notification, handlers) {
-  const handler = handlers[notification.method];
-  if (!handler) return;
-  handler(notification);
-}
+  handleRateLimits(rateLimits) {
+    const snapshot = extractRateLimitsSnapshot(rateLimits);
+    if (snapshot) {
+      this.emitQuotaStatus(snapshot);
+    }
+  }
+  async refreshQuotaSnapshot(host) {
+    try {
+      const response = await host.client.request(
+        ACCOUNT_RATE_LIMITS_READ_METHOD,
+        void 0
+      );
+      this.handleRateLimits(response.rateLimits);
+    } catch {
+    }
+  }
+  emitQuotaStatus(snapshot, force = false) {
+    const event = this.quotaStatus.apply(snapshot, force);
+    if (!event) return;
+    this.historyEvents.push(event);
+    this.onEvent(event);
+  }
+  emitCodexTokenUsage(tokenUsage, model) {
+    const payload = buildCodexTokenUsageContextUsagePayload({
+      model,
+      modelContextWindow: tokenUsage.modelContextWindow,
+      last: {
+        inputTokens: tokenUsage.last.inputTokens,
+        outputTokens: tokenUsage.last.outputTokens,
+        totalTokens: tokenUsage.last.totalTokens,
+        cachedInputTokens: tokenUsage.last.cachedInputTokens,
+        reasoningOutputTokens: tokenUsage.last.reasoningOutputTokens
+      },
+      total: {
+        totalTokens: tokenUsage.total.totalTokens
+      },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    const event = this.emitContextUsage(payload);
+    this.historyEvents.push(event);
+  }
+};
 
-// src/managers/codex-asp/codex-asp-manager.ts
-function historyEventKey(event) {
-  const payloadType = typeof event.payload.type === "string" ? event.payload.type : null;
-  const callId = typeof event.payload.call_id === "string" ? event.payload.call_id : null;
-  const itemId = typeof event.payload[CODEX_ASP_ITEM_ID_PAYLOAD_KEY] === "string" ? event.payload[CODEX_ASP_ITEM_ID_PAYLOAD_KEY] : null;
-  const messageId = typeof event.payload[USER_MESSAGE_ID_PAYLOAD_KEY] === "string" ? event.payload[USER_MESSAGE_ID_PAYLOAD_KEY] : null;
-  if (event.type === "response_item" && payloadType && callId) {
-    return `${event.type}:${payloadType}:${callId}`;
-  }
-  if (event.type === "event_msg" && event.payload.type === "user_message") {
-    if (messageId) return `${event.type}:user_message:message:${messageId}`;
-    if (itemId) return `${event.type}:user_message:item:${itemId}`;
-    const command = typeof event.payload.command === "string" ? event.payload.command : "";
-    const message = typeof event.payload.message === "string" ? event.payload.message : "";
-    return `${event.type}:user_message:${event.timestamp}:${command}:${message}`;
-  }
-  if (itemId && payloadType) {
-    return `${event.type}:${payloadType}:item:${itemId}`;
-  }
-  return `${event.type}:${event.timestamp}:${JSON.stringify(event.payload)}`;
-}
-function areDuplicateHistoryEvents(a, b) {
-  if (historyEventKey(a) === historyEventKey(b)) return true;
-  return areSameUserMessageEvents(a, b);
-}
-function mergeHistoryEvent(current, candidate) {
-  if (getUserMessage(current) && getUserMessage(current) === getUserMessage(candidate)) {
-    return {
-      ...current,
-      timestamp: getEventTimestampMs(current) <= getEventTimestampMs(candidate) ? current.timestamp : candidate.timestamp,
-      payload: {
-        ...current.payload,
-        ...candidate.payload
-      }
-    };
+// src/managers/codex-manager.ts
+import { Codex } from "@openai/codex-sdk";
+import { readdir as readdir3, stat as stat2, writeFile as writeFile8, mkdir as mkdir10, readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir12 } from "os";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+var DEFAULT_MODEL2 = "gpt-5.5";
+var CODEX_CONFIG_PATH = join14(homedir12(), ".codex", "config.toml");
+function isJsonlEvent2(value) {
+  if (!isRecord4(value)) {
+    return false;
   }
-  return candidate;
+  return typeof value.timestamp === "string" && typeof value.type === "string" && isRecord4(value.payload);
 }
-function mergeHistoryEvents(primary, supplemental) {
-  return mergeAgentEvents(primary, supplemental, {
-    areDuplicates: areDuplicateHistoryEvents,
-    mergeEvent: mergeHistoryEvent
-  });
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
-var CodexAspManager = class extends CodingAgentManager {
+var CodexManager = class extends CodingAgentManager {
+  codex;
   currentThreadId = null;
-  activeTurnId = null;
-  threadAttached = false;
-  historyEvents = [];
-  emittedItemStages = /* @__PURE__ */ new Set();
+  currentThread = null;
+  activeAbortController = null;
   quotaStatus = new CodexQuotaStatusTracker();
-  currentGoal = null;
   constructor(options) {
     super(options);
+    this.codex = this.createCodexClient();
     this.initializeManager(this.processMessageInternal.bind(this));
   }
+  createCodexClient() {
+    const codexApiKey = resolveCodexApiKey();
+    return new Codex({
+      env: buildCodexAgentEnv(),
+      ...codexApiKey ? { apiKey: codexApiKey } : {}
+    });
+  }
+  resetCodexClient() {
+    this.codex = this.createCodexClient();
+    this.currentThread = null;
+  }
   async initialize() {
     if (this.initialSessionId) {
       this.currentThreadId = this.initialSessionId;
+      console.log(`[CodexManager] Restored thread ID from persisted state: ${this.currentThreadId}`);
     }
   }
-  async interruptActiveTurn() {
-    if (!this.currentThreadId || !this.activeTurnId) {
-      return;
-    }
+  async flushQuotaSnapshotFromCurrentSession() {
+    if (!this.currentThreadId) return;
     try {
-      const host = await getCodexAspHost();
-      const params = {
-        threadId: this.currentThreadId,
-        turnId: this.activeTurnId
-      };
-      await host.client.request(TURN_INTERRUPT_METHOD, params);
+      const sessionFile = await this.findSessionFile(this.currentThreadId);
+      if (!sessionFile) return;
+      const content = await readFile7(sessionFile, "utf-8");
+      const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
+      let latest = null;
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
+          if (snapshot) {
+            latest = snapshot;
+          }
+        } catch {
+        }
+      }
+      if (latest) {
+        this.emitQuotaStatus(latest);
+      }
     } catch (error) {
-      console.warn("[CodexAspManager] Failed to interrupt active turn:", error);
+      console.warn("[CodexManager] Failed to flush quota snapshot from session:", error);
     }
   }
-  async getHistory() {
-    if (!this.currentThreadId) {
-      return { thread_id: null, events: [], goal: null };
+  emitQuotaStatus(snapshot, force = false) {
+    const event = this.quotaStatus.apply(snapshot, force);
+    if (event) this.onEvent(event);
+  }
+  async interruptActiveTurn() {
+    if (this.activeAbortController) {
+      this.activeAbortController.abort();
     }
+  }
+  /**
+   * Update the developer_instructions in ~/.codex/config.toml
+   * This sets the system prompt that Codex will use for this turn
+   */
+  async updateCodexConfig(developerInstructions) {
     try {
-      const host = await getCodexAspHost();
-      const [response] = await Promise.all([
-        host.client.request(
-          THREAD_READ_METHOD,
-          { threadId: this.currentThreadId, includeTurns: true }
-        ),
-        this.refreshThreadGoal(host, this.currentThreadId)
-      ]);
-      const events = mergeHistoryEvents(this.historyEvents, threadToHistoryEvents(response.thread));
-      this.historyEvents.splice(0, this.historyEvents.length, ...events);
-      return {
-        thread_id: this.currentThreadId,
-        events,
-        goal: this.currentGoal
-      };
-    } catch {
+      const codexDir = join14(homedir12(), ".codex");
+      await mkdir10(codexDir, { recursive: true });
+      let config = {};
+      if (existsSync6(CODEX_CONFIG_PATH)) {
+        try {
+          const existingContent = await readFile7(CODEX_CONFIG_PATH, "utf-8");
+          const parsed = parseToml(existingContent);
+          if (isRecord4(parsed)) {
+            config = parsed;
+          }
+        } catch (parseError) {
+          console.warn("[CodexManager] Failed to parse existing config.toml, starting fresh:", parseError);
+        }
+      }
+      if (developerInstructions) {
+        config.developer_instructions = developerInstructions;
+      } else {
+        delete config.developer_instructions;
+      }
+      const tomlContent = stringifyToml(config);
+      await writeFile8(CODEX_CONFIG_PATH, tomlContent, "utf-8");
+      console.log("[CodexManager] Updated config.toml with developer_instructions");
+    } catch (error) {
+      console.error("[CodexManager] Failed to update config.toml:", error);
     }
-    return {
-      thread_id: this.currentThreadId,
-      events: [...this.historyEvents],
-      goal: this.currentGoal
-    };
-  }
-  getGoal() {
-    return this.currentGoal;
   }
   async processMessageInternal(request) {
-    let userMessageRecorded = false;
-    const recordUserMessage = (extraPayload = {}) => {
-      if (userMessageRecorded) return;
-      userMessageRecorded = true;
-      this.recordHistoryEvent("event_msg", {
-        type: "user_message",
-        message: request.message,
-        ...extraPayload
-      });
-    };
-    const goalCommand = parseGoalCommand(request.message);
-    const dispatch = async () => {
-      if (goalCommand?.type === "clear") {
-        await this.executeGoalClearCommand(request, recordUserMessage);
-        return;
-      }
-      if (goalCommand?.type === "set") {
-        await this.executeAspTurn(request, recordUserMessage, {
-          runTurn: (host, threadId) => this.runGoalTurn(host, threadId, request, goalCommand.objective),
-          userMessagePayload: { command: "goal" }
-        });
-        return;
-      }
-      await this.executeAspTurn(request, recordUserMessage);
-    };
     try {
-      await dispatch();
+      await this.executeCodexTurn(request);
     } catch (error) {
       if (isCodexAuthError(error)) {
         const refreshed = await codexTokenManager.fetchFreshCredentials(error instanceof Error ? error.message : String(error));
         if (refreshed) {
-          await restartCodexAspHost();
-          this.threadAttached = false;
-          await dispatch();
+          this.resetCodexClient();
+          await this.executeCodexTurn(request);
           return;
-        }
-      }
-      throw error;
-    } finally {
-      this.activeTurnId = null;
-      await this.onTurnComplete();
-    }
-  }
-  async executeGoalClearCommand(request, recordUserMessage) {
-    const host = await getCodexAspHost();
-    const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
-    recordUserMessage({ command: "goal" });
-    const threadId = await this.ensureThread(host, request, developerInstructions);
-    await host.client.request(
-      THREAD_GOAL_CLEAR_METHOD,
-      { threadId }
-    );
-    this.recordGoalChange(null, true);
-  }
-  async executeAspTurn(request, recordUserMessage, options = {}) {
-    const host = await getCodexAspHost();
-    if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
-      await this.refreshQuotaSnapshot(host);
-      if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
-        recordUserMessage(options.userMessagePayload);
-        this.emitQuotaStatus(this.quotaStatus.latestSnapshot, true);
-        return;
-      }
-    }
-    const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
-    recordUserMessage(options.userMessagePayload);
-    const threadId = await this.ensureThread(host, request, developerInstructions);
-    const runTurn = options.runTurn ?? ((aspHost, aspThreadId, aspInstructions) => this.runTurn(aspHost, aspThreadId, request, aspInstructions));
-    let completedTurn;
-    try {
-      completedTurn = await runTurn(host, threadId, developerInstructions);
-    } catch (error) {
-      await this.refreshQuotaSnapshot(host);
-      if (this.quotaStatus.blocked) {
-        return;
-      }
-      throw error;
-    }
-    if (completedTurn.status === "failed") {
-      await this.refreshQuotaSnapshot(host);
-      if (this.quotaStatus.blocked) {
-        return;
-      }
-      throw new Error(formatTurnFailure(completedTurn));
-    }
-    if (completedTurn.status === "completed") {
-      this.emitTurnCompletedItems(completedTurn);
-    }
-  }
-  async ensureThread(host, request, developerInstructions) {
-    if (this.currentThreadId) {
-      if (!this.threadAttached) {
-        const response = await host.client.request(
-          THREAD_RESUME_METHOD,
-          await buildThreadResumeParams(this.workingDirectory, this.currentThreadId, request, developerInstructions)
-        );
-        this.currentThreadId = response.thread.id;
-        this.threadAttached = true;
-        this.seedHistoryFromThread(response.thread);
-        await this.onSaveSessionId(this.currentThreadId);
+        }
       }
-      return this.currentThreadId;
+      throw error;
     }
-    const threadStartResponse = await host.client.request(
-      THREAD_START_METHOD,
-      await buildThreadStartParams(this.workingDirectory, request, developerInstructions)
-    );
-    this.currentThreadId = threadStartResponse.thread.id;
-    this.threadAttached = true;
-    await this.onSaveSessionId(this.currentThreadId);
-    return this.currentThreadId;
-  }
-  async runTurn(host, threadId, request, developerInstructions) {
-    const { params, tempImagePaths } = await buildTurnStartParams(threadId, request, developerInstructions);
-    return this.observeTurn(host, threadId, request, async () => {
-      const turnStartResponse = await host.client.request(
-        TURN_START_METHOD,
-        params
-      );
-      return { turn: turnStartResponse.turn, tempImagePaths };
-    });
-  }
-  async runGoalTurn(host, threadId, request, objective) {
-    return this.observeTurn(host, threadId, request, async () => {
-      const response = await host.client.request(
-        THREAD_GOAL_SET_METHOD,
-        { threadId, objective, status: "active" }
-      );
-      this.recordGoalChange(response.goal, true);
-      return { turn: null, tempImagePaths: [] };
-    });
   }
-  async observeTurn(host, threadId, request, startTurn) {
-    let resolveCompleted;
-    const completed = new Promise((resolve3) => {
-      resolveCompleted = resolve3;
-    });
-    let rejectDisposed = () => {
-    };
-    const disposed = new Promise((_resolve, reject) => {
-      rejectDisposed = reject;
-    });
-    void disposed.catch(() => {
-    });
-    let observedTurnId = null;
-    const completedItems = [];
-    const agentMessageDeltas = /* @__PURE__ */ new Map();
+  async executeCodexTurn(request) {
+    if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
+      await this.flushQuotaSnapshotFromCurrentSession();
+      if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
+        this.emitQuotaStatus(this.quotaStatus.latestSnapshot, true);
+        try {
+          await this.onTurnComplete();
+        } catch (error) {
+          console.error("[CodexManager] onTurnComplete failed during quota-blocked turn:", error);
+        }
+        return;
+      }
+    }
+    const {
+      message,
+      model,
+      customInstructions,
+      images,
+      permissionMode,
+      thinkingLevel
+    } = request;
     const linearSessionId = ENGINE_ENV.LINEAR_SESSION_ID;
-    const model = request.model ?? DEFAULT_MODEL2;
     let tempImagePaths = [];
-    const linearForwarder = new LinearEventForwarder(linearSessionId);
-    const matchesTurn = (notificationThreadId, notificationTurnId) => notificationThreadId === threadId && (!observedTurnId || notificationTurnId === null || notificationTurnId === observedTurnId);
-    const handlers = {
-      [ACCOUNT_RATE_LIMITS_UPDATED_METHOD]: (notification) => {
-        this.handleRateLimits(notification.params.rateLimits);
-      },
-      [THREAD_TOKEN_USAGE_UPDATED_METHOD]: (notification) => {
-        if (notification.params.threadId !== threadId) return;
-        this.emitCodexTokenUsage(notification.params.tokenUsage, model);
-      },
-      [THREAD_GOAL_UPDATED_METHOD]: (notification) => {
-        if (notification.params.threadId !== threadId) return;
-        this.recordGoalChange(notification.params.goal);
-      },
-      [THREAD_GOAL_CLEARED_METHOD]: (notification) => {
-        if (notification.params.threadId !== threadId) return;
-        this.recordGoalChange(null);
-      },
-      [THREAD_COMPACTED_METHOD]: (notification) => {
-        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.setCompacting(false);
-      },
-      [TURN_STARTED_METHOD]: (notification) => {
-        if (notification.params.threadId !== threadId) return;
-        observedTurnId = notification.params.turn.id;
-        this.activeTurnId = notification.params.turn.id;
-        linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
-      },
-      [TURN_PLAN_UPDATED_METHOD]: (notification) => {
-        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        this.emitPlanUpdate(notification.params.plan);
-        linearForwarder.sendPlan(extractPlanFromCodexAspNotification(notification));
-      },
-      [ITEM_STARTED_METHOD]: (notification) => {
-        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        if (notification.params.item.type === "contextCompaction") {
-          this.setCompacting(true);
-        }
-        this.emitThreadItemLifecycle(notification.params.item, "started");
-        linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
-      },
-      [ITEM_COMPLETED_METHOD]: (notification) => {
-        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        completedItems.push(notification.params.item);
-        if (notification.params.item.type === "contextCompaction") {
-          this.setCompacting(false);
-        }
-        this.emitThreadItemLifecycle(notification.params.item, "completed");
-        linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
-      },
-      [AGENT_MESSAGE_DELTA_METHOD]: (notification) => {
-        if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
-        const currentText = agentMessageDeltas.get(notification.params.itemId) ?? "";
-        agentMessageDeltas.set(notification.params.itemId, currentText + notification.params.delta);
-      },
-      [TURN_COMPLETED_METHOD]: (notification) => {
-        if (notification.params.threadId !== threadId) return;
-        observedTurnId = notification.params.turn.id;
-        const turn = notification.params.turn;
-        const items = turn.items.length > 0 ? [...turn.items] : [];
-        const itemIds = new Set(items.map((item) => item.id));
-        for (const item of completedItems) {
-          if (!itemIds.has(item.id)) {
-            items.push(item);
-            itemIds.add(item.id);
+    let stopTail = null;
+    let abortController = null;
+    try {
+      if (images && images.length > 0) {
+        const normalizedImages = await normalizeImages(images);
+        tempImagePaths = await saveNormalizedImagesToTempFiles(normalizedImages);
+      }
+      const developerInstructions = this.buildCombinedInstructions(customInstructions);
+      await this.updateCodexConfig(developerInstructions);
+      const sandboxMode = "danger-full-access";
+      const webSearchMode = "live";
+      const codexReasoningEffort = codexReasoningEffortForThinkingLevel(thinkingLevel);
+      const additionalDirectories = await getAgentAdditionalDirectories();
+      const threadOptions = {
+        workingDirectory: this.workingDirectory,
+        skipGitRepoCheck: true,
+        sandboxMode,
+        model: model || DEFAULT_MODEL2,
+        webSearchMode,
+        additionalDirectories,
+        ...codexReasoningEffort ? { modelReasoningEffort: codexReasoningEffort } : {}
+      };
+      abortController = new AbortController();
+      this.activeAbortController = abortController;
+      if (this.currentThreadId) {
+        this.currentThread = this.codex.resumeThread(this.currentThreadId, threadOptions);
+      } else {
+        this.currentThread = this.codex.startThread(threadOptions);
+        const { events } = await this.currentThread.runStreamed("Hello", { signal: abortController.signal });
+        for await (const event of events) {
+          if (event.type === "thread.started") {
+            this.currentThreadId = event.thread_id;
+            await this.onSaveSessionId(this.currentThreadId);
+            console.log(`[CodexManager] Captured and persisted thread ID: ${this.currentThreadId}`);
           }
         }
-        for (const [itemId, text] of agentMessageDeltas) {
-          if (!itemIds.has(itemId)) {
-            items.push({
-              type: "agentMessage",
-              id: itemId,
-              text,
-              phase: null,
-              memoryCitation: null
-            });
-          }
+        if (!this.currentThreadId && this.currentThread.id) {
+          this.currentThreadId = this.currentThread.id;
+          await this.onSaveSessionId(this.currentThreadId);
+          console.log(`[CodexManager] Captured and persisted thread ID from thread.id: ${this.currentThreadId}`);
         }
-        resolveCompleted(items.length > 0 ? { ...turn, items, itemsView: "full" } : turn);
       }
-    };
-    const onNotification = (notification) => {
-      dispatchAspNotification(notification, handlers);
-    };
-    const onServerRequest = (serverRequest) => {
-      if (serverRequest.method !== COMMAND_APPROVAL_METHOD && serverRequest.method !== FILE_CHANGE_APPROVAL_METHOD) {
-        return;
+      stopTail = this.currentThreadId ? await this.startSessionTail(this.currentThreadId) : null;
+      let input;
+      if (tempImagePaths.length > 0) {
+        const inputItems = [
+          { type: "text", text: message },
+          ...tempImagePaths.map((path4) => ({ type: "local_image", path: path4 }))
+        ];
+        input = inputItems;
+      } else {
+        input = message;
       }
-      console.warn("[CodexAspManager] approval requested while sandbox is danger-full-access");
-      host.client.respond(serverRequest.id, { decision: "accept" });
-    };
-    const onDispose = (reason) => {
-      this.threadAttached = false;
-      this.activeTurnId = null;
-      const turnLabel = observedTurnId ? ` ${observedTurnId}` : "";
-      rejectDisposed(new Error(`Codex ASP client disposed before turn${turnLabel} completed: ${reason.message}`));
-    };
-    host.client.on("notification", onNotification);
-    host.client.on("serverRequest", onServerRequest);
-    host.client.on("dispose", onDispose);
-    try {
-      const started = await startTurn();
-      tempImagePaths = started.tempImagePaths;
-      if (started.turn) {
-        observedTurnId = started.turn.id;
-        this.activeTurnId = started.turn.id;
+      try {
+        const { events } = await this.currentThread.runStreamed(input, { signal: abortController.signal });
+        const linearForwarder = new LinearEventForwarder(linearSessionId);
+        for await (const event of events) {
+          if (linearSessionId) {
+            linearForwarder.sendPlan(extractPlanFromCodexEvent(event));
+            linearForwarder.sendEvent(convertCodexEvent(event, linearSessionId));
+          }
+        }
+        linearForwarder.flushThoughtAsResponse();
+      } catch (error) {
+        await this.flushQuotaSnapshotFromCurrentSession();
+        if (this.quotaStatus.blocked) {
+          return;
+        }
+        throw error;
       }
-      const turn = await Promise.race([completed, disposed]);
-      linearForwarder.flushThoughtAsResponse();
-      return turn;
     } finally {
-      host.client.off("notification", onNotification);
-      host.client.off("serverRequest", onServerRequest);
-      host.client.off("dispose", onDispose);
+      if (stopTail) {
+        await stopTail();
+      }
       await removeTempImageFiles(tempImagePaths);
-      if (host.client.isDisposed) {
-        this.threadAttached = false;
+      try {
+        await this.onTurnComplete();
+      } catch (error) {
+        console.error("[CodexManager] onTurnComplete failed:", error);
       }
+      this.activeAbortController = null;
     }
   }
-  emitThreadItemLifecycle(item, lifecycle) {
-    const stageKey = `${lifecycle}:${item.id}`;
-    if (this.emittedItemStages.has(stageKey)) {
-      return;
-    }
-    if (lifecycle === "completed" && !this.emittedItemStages.has(`started:${item.id}`)) {
-      this.emittedItemStages.add(`started:${item.id}`);
-      this.recordAndEmitDrafts(itemToAgentEventDrafts(item, "started"));
+  async getHistory() {
+    if (!this.currentThreadId) {
+      return {
+        thread_id: null,
+        events: []
+      };
     }
-    this.emittedItemStages.add(stageKey);
-    this.recordAndEmitDrafts(itemToAgentEventDrafts(item, lifecycle));
-  }
-  emitTurnCompletedItems(turn) {
-    for (const item of turn.items) {
-      this.emitThreadItemLifecycle(item, "completed");
+    const sessionFile = await this.findSessionFile(this.currentThreadId);
+    if (!sessionFile) {
+      return {
+        thread_id: this.currentThreadId,
+        events: []
+      };
     }
+    const events = await readJSONL(sessionFile);
+    return {
+      thread_id: this.currentThreadId,
+      events
+    };
   }
-  emitPlanUpdate(plan) {
-    if (plan.length === 0) return;
-    this.recordAndEmitDrafts([{
-      type: "response_item",
-      payload: {
-        type: "function_call",
-        name: "update_plan",
-        call_id: `plan-${Date.now()}`,
-        arguments: JSON.stringify({ plan })
+  // Helper methods for finding session files
+  async findSessionFile(threadId) {
+    const sessionsDir = join14(homedir12(), ".codex", "sessions");
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const year = now.getFullYear();
+      const month = String(now.getMonth() + 1).padStart(2, "0");
+      const day = String(now.getDate()).padStart(2, "0");
+      const todayDir = join14(sessionsDir, String(year), month, day);
+      const file = await this.findFileInDirectory(todayDir, threadId);
+      if (file) return file;
+      for (let daysAgo = 1; daysAgo <= 7; daysAgo++) {
+        const date = new Date(now);
+        date.setDate(date.getDate() - daysAgo);
+        const searchYear = date.getFullYear();
+        const searchMonth = String(date.getMonth() + 1).padStart(2, "0");
+        const searchDay = String(date.getDate()).padStart(2, "0");
+        const searchDir = join14(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const file2 = await this.findFileInDirectory(searchDir, threadId);
+        if (file2) return file2;
       }
-    }]);
-  }
-  seedHistoryFromThread(thread) {
-    const events = threadToHistoryEvents(thread);
-    this.historyEvents.splice(0, this.historyEvents.length, ...mergeHistoryEvents(this.historyEvents, events));
+      return null;
+    } catch (error) {
+      return null;
+    }
   }
-  async refreshThreadGoal(host, threadId) {
+  async findFileInDirectory(directory, threadId) {
     try {
-      const response = await host.client.request(
-        THREAD_GOAL_GET_METHOD,
-        { threadId }
-      );
-      this.currentGoal = response.goal ? aspGoalToChatGoal(response.goal) : null;
+      const files = await readdir3(directory);
+      for (const file of files) {
+        if (file.endsWith(".jsonl") && file.includes(threadId)) {
+          const fullPath = join14(directory, file);
+          const stats = await stat2(fullPath);
+          if (stats.isFile()) {
+            return fullPath;
+          }
+        }
+      }
+      return null;
     } catch (error) {
-      console.warn("[CodexAspManager] Failed to read ASP thread goal:", error);
+      return null;
     }
   }
-  recordGoalChange(goal, force = false) {
-    const nextGoal = goal ? aspGoalToChatGoal(goal) : null;
-    if (!force && JSON.stringify(this.currentGoal) === JSON.stringify(nextGoal)) {
-      return;
+  async waitForSessionFile(threadId, timeoutMs = 5e3) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+      const sessionFile = await this.findSessionFile(threadId);
+      if (sessionFile) {
+        return sessionFile;
+      }
+      await sleep(100);
     }
-    this.currentGoal = nextGoal;
-    const event = this.recordHistoryEvent(
-      CHAT_GOAL_EVENT_TYPE,
-      { goal: nextGoal }
-    );
-    this.onEvent(event);
+    return null;
   }
-  recordAndEmitDrafts(drafts) {
-    for (const draft of drafts) {
-      const event = this.recordHistoryEvent(draft.type, draft.payload);
-      this.onEvent(event);
+  // @openai/codex-sdk doesn't expose manual /compact (TUI-only); we only mirror the auto-compaction rollout entries to the UI.
+  trackNativeCompaction(event) {
+    if (event.type === "compacted") {
+      this.setCompacting(false);
+      return;
     }
-  }
-  recordHistoryEvent(type, payload) {
-    const event = {
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      type,
-      payload
-    };
-    this.historyEvents.push(event);
-    return event;
-  }
-  handleRateLimits(rateLimits) {
-    const snapshot = extractRateLimitsSnapshot(rateLimits);
-    if (snapshot) {
-      this.emitQuotaStatus(snapshot);
+    if (event.type !== "event_msg") return;
+    const msg = event.payload.msg;
+    if (!msg) return;
+    const itemType = msg.payload?.item?.type;
+    if (itemType !== "context_compaction") return;
+    if (msg.type === "item_started") {
+      this.setCompacting(true);
+    } else if (msg.type === "item_completed") {
+      this.setCompacting(false);
     }
   }
-  async refreshQuotaSnapshot(host) {
-    try {
-      const response = await host.client.request(
-        ACCOUNT_RATE_LIMITS_READ_METHOD,
-        void 0
-      );
-      this.handleRateLimits(response.rateLimits);
-    } catch {
+  async startSessionTail(threadId) {
+    const sessionFile = await this.waitForSessionFile(threadId);
+    if (!sessionFile) {
+      return async () => {
+      };
     }
-  }
-  emitQuotaStatus(snapshot, force = false) {
-    const event = this.quotaStatus.apply(snapshot, force);
-    if (!event) return;
-    this.historyEvents.push(event);
-    this.onEvent(event);
-  }
-  emitCodexTokenUsage(tokenUsage, model) {
-    const payload = buildCodexTokenUsageContextUsagePayload({
-      model,
-      modelContextWindow: tokenUsage.modelContextWindow,
-      last: {
-        inputTokens: tokenUsage.last.inputTokens,
-        outputTokens: tokenUsage.last.outputTokens,
-        totalTokens: tokenUsage.last.totalTokens,
-        cachedInputTokens: tokenUsage.last.cachedInputTokens,
-        reasoningOutputTokens: tokenUsage.last.reasoningOutputTokens
-      },
-      total: {
-        totalTokens: tokenUsage.total.totalTokens
-      },
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    const event = this.emitContextUsage(payload);
-    this.historyEvents.push(event);
+    let active = true;
+    const seenLines = /* @__PURE__ */ new Set();
+    const seedSeenLines = async () => {
+      try {
+        const content = await readFile7(sessionFile, "utf-8");
+        const lines = content.split("\n").map((line) => line.trim()).filter(Boolean);
+        let latest = null;
+        for (const line of lines) {
+          seenLines.add(line);
+          try {
+            const parsed = JSON.parse(line);
+            const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
+            if (snapshot) latest = snapshot;
+          } catch {
+          }
+        }
+        if (latest) {
+          this.quotaStatus.prime(latest);
+        }
+      } catch {
+      }
+    };
+    await seedSeenLines();
+    const pump = async () => {
+      let emitted = 0;
+      try {
+        const content = await readFile7(sessionFile, "utf-8");
+        const lines = content.split("\n");
+        const completeLines = content.endsWith("\n") ? lines : lines.slice(0, -1);
+        for (const line of completeLines) {
+          const trimmed = line.trim();
+          if (!trimmed || seenLines.has(trimmed)) {
+            continue;
+          }
+          seenLines.add(trimmed);
+          try {
+            const parsed = JSON.parse(trimmed);
+            const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
+            if (snapshot) {
+              this.emitQuotaStatus(snapshot);
+            }
+            if (isJsonlEvent2(parsed)) {
+              this.trackNativeCompaction(parsed);
+              this.onEvent(parsed);
+              emitted += 1;
+            }
+          } catch {
+          }
+        }
+      } catch {
+      }
+      return emitted;
+    };
+    const loop = (async () => {
+      while (active) {
+        await pump();
+        await sleep(100);
+      }
+      await pump();
+    })();
+    return async () => {
+      active = false;
+      await loop;
+      const deadline = Date.now() + 1500;
+      while (Date.now() < deadline) {
+        const emitted = await pump();
+        if (emitted > 0) {
+          continue;
+        }
+        await sleep(100);
+      }
+    };
   }
 };
 
@@ -7610,18 +7931,58 @@ var RELAY_HISTORY_DIR = join15(ENGINE_DIR2, "relay-histories");
 var CHAT_SENDERS_DIR = join15(ENGINE_DIR2, "chat-senders");
 var CODEX_AUTH_PATH2 = join15(homedir13(), ".codex", "auth.json");
 function isChatMessageSender(value) {
-  if (!isRecord3(value)) return false;
+  if (!isRecord4(value)) return false;
   return typeof value.senderUserId === "string" && typeof value.senderEmail === "string" && typeof value.recordedAt === "string";
 }
 function isCodexAvailable() {
   return existsSync7(CODEX_AUTH_PATH2) || Boolean(ENGINE_ENV.OPENAI_API_KEY);
 }
+function isSameAcceptedUserEvent(event, acceptedEvent) {
+  if (areSameUserMessageEvents(event, acceptedEvent)) return true;
+  const eventMessage = getUserMessage(event);
+  const acceptedMessage = getUserMessage(acceptedEvent);
+  return Boolean(eventMessage) && eventMessage === acceptedMessage && Math.abs(getEventTimestampMs(event) - getEventTimestampMs(acceptedEvent)) <= 3e4;
+}
+function getCodexTranscriptUserMessages(transcript) {
+  if (!transcript) return [];
+  const messages = [];
+  for (const turn of transcript.turns) {
+    for (const item of turn.items) {
+      if (item.type === "userMessage" && item.content.trim()) {
+        messages.push(item.content);
+      }
+    }
+  }
+  return messages;
+}
+function getCodexTranscriptFromEvent(event) {
+  if (event.type !== CODEX_ASP_TRANSCRIPT_UPDATED_EVENT_TYPE) return null;
+  const transcript = event.payload.transcript;
+  return isCodexAspTranscript(transcript) ? transcript : null;
+}
+function acceptedEventInCodexTranscript(acceptedEvent, transcript) {
+  const message = getUserMessage(acceptedEvent);
+  if (!message) return false;
+  return getCodexTranscriptUserMessages(transcript).includes(message);
+}
 function isPersistedChat(value) {
-  if (!isRecord3(value)) {
+  if (!isRecord4(value)) {
     return false;
   }
   const candidate = value;
-  return typeof candidate.id === "string" && (candidate.provider === "claude" || candidate.provider === "codex" || candidate.provider === "relay") && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && (candidate.providerSessionId === null || typeof candidate.providerSessionId === "string") && (candidate.parentChatId === void 0 || candidate.parentChatId === null || typeof candidate.parentChatId === "string");
+  return typeof candidate.id === "string" && (candidate.provider === "claude" || candidate.provider === "codex" || candidate.provider === "relay") && typeof candidate.title === "string" && typeof candidate.createdAt === "string" && typeof candidate.updatedAt === "string" && (candidate.providerSessionId === null || typeof candidate.providerSessionId === "string") && (candidate.parentChatId === void 0 || candidate.parentChatId === null || typeof candidate.parentChatId === "string") && (candidate.codexBackend === void 0 || candidate.codexBackend === "sdk" || candidate.codexBackend === "asp");
+}
+function codexBackendForChat(chat) {
+  if (chat.provider !== "codex") return "asp";
+  if (chat.codexBackend) return chat.codexBackend;
+  return chat.providerSessionId ? "sdk" : "asp";
+}
+function normalizePersistedChat(chat) {
+  return {
+    ...chat,
+    parentChatId: chat.parentChatId ?? null,
+    ...chat.provider === "codex" ? { codexBackend: codexBackendForChat(chat) } : {}
+  };
 }
 function createUserMessageEvent(message, messageId) {
   return {
@@ -7635,7 +7996,6 @@ function createUserMessageEvent(message, messageId) {
     }
   };
 }
-var isSameUserMessageEvent = areSameUserMessageEvents;
 var ChatService = class {
   constructor(workingDirectory) {
     this.workingDirectory = workingDirectory;
@@ -7699,7 +8059,8 @@ var ChatService = class {
       createdAt: now,
       updatedAt: now,
       providerSessionId: null,
-      parentChatId
+      parentChatId,
+      ...request.provider === "codex" ? { codexBackend: "asp" } : {}
     };
     const runtime = this.createRuntimeChat(persisted);
     this.chats.set(persisted.id, runtime);
@@ -7796,6 +8157,37 @@ var ChatService = class {
     });
     return result;
   }
+  async clearGoal(chatId) {
+    const chat = this.requireChat(chatId);
+    if (!chat.provider.clearGoal) {
+      return { interrupted: false, queue: [], goal: null };
+    }
+    const interruptResult = await chat.provider.interrupt();
+    chat.hasActiveTurn = false;
+    chat.activeMessageId = null;
+    keepAliveService.stop();
+    chat.pendingMessageIds = [];
+    chat.acceptedUserEvents.clear();
+    const goal = await chat.provider.clearGoal();
+    this.touch(chat);
+    await this.publish({
+      type: "chat.interrupted",
+      payload: {
+        chatId,
+        interrupted: interruptResult.interrupted,
+        queue: interruptResult.queue
+      }
+    });
+    await this.publish({
+      type: "chat.updated",
+      payload: { chat: this.toSummary(chat) }
+    });
+    return {
+      interrupted: interruptResult.interrupted,
+      queue: interruptResult.queue,
+      goal
+    };
+  }
   getChatQueue(chatId) {
     const chat = this.requireChat(chatId);
     return {
@@ -7874,10 +8266,17 @@ var ChatService = class {
       chat.provider.getHistory(),
       this.readSenders(chatId)
     ]);
-    const acceptedEvents = [...chat.acceptedUserEvents.values()].filter((acceptedEvent) => !history.events.some((event) => isSameUserMessageEvent(event, acceptedEvent)));
+    for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
+      if (acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript)) {
+        chat.acceptedUserEvents.delete(messageId);
+      }
+    }
+    const acceptedEvents = [...chat.acceptedUserEvents.values()].filter((acceptedEvent) => !acceptedEventInCodexTranscript(acceptedEvent, history.codexAspTranscript) && !history.events.some((event) => isSameAcceptedUserEvent(event, acceptedEvent)));
+    const events = [...history.events, ...acceptedEvents].sort((a, b) => getEventTimestampMs(a) - getEventTimestampMs(b));
     return {
       thread_id: history.thread_id,
-      events: [...history.events, ...acceptedEvents],
+      events,
+      codexAspTranscript: history.codexAspTranscript ?? null,
       goal: history.goal ?? chat.provider.getGoal?.() ?? null,
       senders
     };
@@ -7932,7 +8331,7 @@ var ChatService = class {
         codexAvailable: isCodexAvailable()
       });
     } else {
-      const CodexProviderCtor = ENGINE_ENV.CODEX_ASP_ENABLED ? CodexAspManager : CodexManager;
+      const CodexProviderCtor = codexBackendForChat(persisted) === "sdk" ? CodexManager : CodexAspManager;
       provider = new CodexProviderCtor({
         workingDirectory: this.workingDirectory,
         initialSessionId: persisted.providerSessionId,
@@ -8013,12 +8412,20 @@ var ChatService = class {
         };
       }
       for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
-        if (isSameUserMessageEvent(event, acceptedEvent)) {
+        if (isSameAcceptedUserEvent(event, acceptedEvent)) {
           chat.acceptedUserEvents.delete(messageId);
           break;
         }
       }
     }
+    const codexTranscript = getCodexTranscriptFromEvent(event);
+    if (codexTranscript) {
+      for (const [messageId, acceptedEvent] of chat.acceptedUserEvents) {
+        if (acceptedEventInCodexTranscript(acceptedEvent, codexTranscript)) {
+          chat.acceptedUserEvents.delete(messageId);
+        }
+      }
+    }
     this.touch(chat);
     this.observeCurrentBranches(chat).catch(() => {
     });
@@ -8072,7 +8479,7 @@ var ChatService = class {
       if (!Array.isArray(parsed)) {
         return [];
       }
-      return parsed.filter((entry) => isPersistedChat(entry));
+      return parsed.filter((entry) => isPersistedChat(entry)).map((entry) => normalizePersistedChat(entry));
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
         return [];
@@ -9067,6 +9474,17 @@ function createV1Routes(deps) {
       return c.json(jsonError("Failed to interrupt chat", error instanceof Error ? error.message : "Unknown error"), 404);
     }
   });
+  app2.post("/chats/:chatId/goal/clear", async (c) => {
+    try {
+      const result = await deps.chatService.clearGoal(c.req.param("chatId"));
+      return c.json(result);
+    } catch (error) {
+      if (error instanceof ChatNotFoundError) {
+        return c.json(jsonError("Failed to clear goal", error.message), 404);
+      }
+      return c.json(jsonError("Failed to clear goal", error instanceof Error ? error.message : "Unknown error"), 404);
+    }
+  });
   app2.get("/chats/:chatId/queue", (c) => {
     try {
       const result = deps.chatService.getChatQueue(c.req.param("chatId"));