replicas-engine 0.1.212 → 0.1.214

package/dist/src/index.js

@@ -1493,7 +1493,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "25-05-2026-royal-york-v3";
+var DAYTONA_SNAPSHOT_ID = "26-05-2026-royal-york-v2";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -1677,7 +1677,8 @@ 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")
+    REPLICAS_ENV_SYSTEM_PROMPT: readEnv("REPLICAS_ENV_SYSTEM_PROMPT"),
+    CODEX_ASP_ENABLED: readEnv("CODEX_ASP_ENABLED")?.toLowerCase() === "true"
   };
   if (!IS_WARMING_MODE && !env.WORKSPACE_ID) {
     console.error("WORKSPACE_ID is not set \u2014 this is required in normal (non-warming) mode");
@@ -4023,20 +4024,6 @@ var MessageQueueService = class {
 };
 
 // src/managers/coding-agent-manager.ts
-var COMPACT_COMMAND_REGEX = /^\/compact\b\s*(.*)$/s;
-var COMPACT_TURN_MARKER = "\0__replicas_compact_turn__\0";
-var COMPACT_SUMMARY_PROMPT = [
-  "The user has requested a session compaction. Produce a thorough summary of this conversation that captures everything needed to continue the work without the prior context.",
-  "",
-  "Cover at least:",
-  "1. The high-level goal we are working toward and the user's most recent intent.",
-  "2. Key decisions made and the rationale behind them.",
-  "3. Files inspected or modified (paths + the relevant changes).",
-  "4. Open questions, blockers, and pending follow-ups.",
-  "5. Any environment details, credentials, or external systems already configured.",
-  "",
-  "Format the response as Markdown with clear headings. The session will be reset after your reply and your summary re-injected as the prelude to the next user turn; write it so a future agent can resume using only that prelude."
-].join("\n");
 var MAX_INTERRUPT_QUEUE_ITEMS = 1e3;
 var MAX_INTERRUPT_QUEUE_CHARS = 2e5;
 var CodingAgentManager = class {
@@ -4047,9 +4034,7 @@ var CodingAgentManager = class {
   onSaveSessionId;
   onEvent;
   hostOnTurnComplete;
-  compactionInFlight = false;
-  compactionBuffer = "";
-  pendingSessionPrelude = null;
+  compacting = false;
   constructor(options) {
     this.workingDirectory = options.workingDirectory ?? ENGINE_ENV.WORKSPACE_ROOT;
     this.initialSessionId = options.initialSessionId;
@@ -4058,65 +4043,26 @@ var CodingAgentManager = class {
     this.hostOnTurnComplete = options.onTurnComplete;
   }
   onTurnComplete = async () => {
-    if (this.compactionInFlight) {
-      this.compactionInFlight = false;
-      const summary = this.compactionBuffer.trim();
-      this.compactionBuffer = "";
-      this.pendingSessionPrelude = summary.length > 0 ? summary : null;
-      this.emitCompactionStatus("completed");
-      try {
-        await this.clearSessionState();
-      } catch (error) {
-        console.error("[CodingAgentManager] Failed to clear session after compaction:", error);
-      }
+    if (this.compacting) {
+      this.setCompacting(false);
     }
     await this.hostOnTurnComplete();
   };
   isCompacting() {
-    return this.compactionInFlight;
-  }
-  captureCompactionText(text) {
-    if (!this.compactionInFlight) return;
-    const trimmed = text.trim();
-    if (!trimmed) return;
-    this.compactionBuffer = this.compactionBuffer.length > 0 ? `${this.compactionBuffer}
-
-${trimmed}` : trimmed;
-  }
-  consumePendingPrelude(message) {
-    if (!this.pendingSessionPrelude) return message;
-    const prelude = this.pendingSessionPrelude;
-    this.pendingSessionPrelude = null;
-    return `<prior-session-summary>
-${prelude}
-</prior-session-summary>
-
-${message}`;
+    return this.compacting;
   }
-  emitCompactionStatus(state) {
+  // Dedup so a noisy stream of native compaction events doesn't spam the UI with redundant status flips.
+  setCompacting(active) {
+    if (this.compacting === active) return;
+    this.compacting = active;
     this.onEvent({
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       type: COMPACTION_STATUS_EVENT_TYPE,
-      payload: { state }
+      payload: { state: active ? "in_progress" : "completed" }
     });
   }
   initializeManager(processMessage) {
-    const wrappedProcessMessage = async (request) => {
-      if (request.message.startsWith(COMPACT_TURN_MARKER)) {
-        this.compactionInFlight = true;
-        this.compactionBuffer = "";
-        this.emitCompactionStatus("in_progress");
-        const summaryPrompt = this.consumePendingPrelude(
-          request.message.slice(COMPACT_TURN_MARKER.length)
-        );
-        return processMessage({ ...request, message: summaryPrompt });
-      }
-      return processMessage({
-        ...request,
-        message: this.consumePendingPrelude(request.message)
-      });
-    };
-    this.messageQueue = new MessageQueueService(wrappedProcessMessage);
+    this.messageQueue = new MessageQueueService(processMessage);
     this.initialized = this.initialize();
   }
   async interrupt() {
@@ -4136,7 +4082,7 @@ ${message}`;
   getQueue() {
     return this.messageQueue.getQueue().map((m) => ({
       id: m.id,
-      message: m.message.startsWith(COMPACT_TURN_MARKER) ? "/compact" : m.message,
+      message: m.message,
       queuedAt: m.queuedAt,
       ...m.senderUserId ? { senderUserId: m.senderUserId } : {},
       ...m.senderEmail ? { senderEmail: m.senderEmail } : {},
@@ -4151,18 +4097,6 @@ ${message}`;
   }
   async enqueueMessage(request) {
     await this.initialized;
-    const compact = request.message.trimStart().match(COMPACT_COMMAND_REGEX);
-    if (compact) {
-      const guidance = compact[1].trim();
-      const prompt = guidance ? `${COMPACT_SUMMARY_PROMPT}
-
-Additional guidance from the user for the summary:
-${guidance}` : COMPACT_SUMMARY_PROMPT;
-      return this.messageQueue.enqueue({
-        ...request,
-        message: `${COMPACT_TURN_MARKER}${prompt}`
-      });
-    }
     return this.messageQueue.enqueue(request);
   }
   emitContextUsage(payload) {
@@ -4201,7 +4135,7 @@ ${guidance}` : COMPACT_SUMMARY_PROMPT;
     const queue = this.messageQueue.drainQueue({
       maxItems: MAX_INTERRUPT_QUEUE_ITEMS,
       maxChars: MAX_INTERRUPT_QUEUE_CHARS
-    }).map((m) => m.startsWith(COMPACT_TURN_MARKER) ? "/compact" : m);
+    });
     return {
       queue,
       isProcessing: this.messageQueue.isProcessing()
@@ -4478,10 +4412,6 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     }
     await this.abortAllPendingToolInputs();
   }
-  async clearSessionState() {
-    this.sessionId = null;
-    await this.onSaveSessionId(null);
-  }
   async abortAllPendingToolInputs() {
     const pending = Array.from(this.pendingToolInputs.values());
     this.pendingToolInputs.clear();
@@ -4839,15 +4769,20 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       console.log(`[ClaudeManager] Captured and persisted session ID: ${this.sessionId}`);
     }
     await this.checkForAuthFailure(message);
-    if (this.isCompacting() && message.type === "assistant") {
-      for (const block of message.message.content) {
-        if (block.type === "text") {
-          this.captureCompactionText(block.text);
-        }
-      }
-    }
+    this.trackNativeCompaction(message);
     await this.recordEvent(message);
   }
+  // Claude Code intercepts /compact and auto-compaction inside the SDK process; we just observe the status messages to mirror state to the UI.
+  trackNativeCompaction(message) {
+    if (message.type !== "system") return;
+    if (message.subtype === "status" && message.status === "compacting") {
+      this.setCompacting(true);
+      return;
+    }
+    if (message.subtype === "compact_boundary") {
+      this.setCompacting(false);
+    }
+  }
   async recordEvent(event) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
     const jsonEvent = {
@@ -5011,11 +4946,6 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
       this.activeAbortController.abort();
     }
   }
-  async clearSessionState() {
-    this.currentThreadId = null;
-    this.currentThread = null;
-    await this.onSaveSessionId(null);
-  }
   /**
    * Update the developer_instructions in ~/.codex/config.toml
    * This sets the system prompt that Codex will use for this turn
@@ -5289,16 +5219,21 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
     }
     return null;
   }
-  bufferCompactionFromEvent(event) {
-    if (!this.isCompacting()) return;
-    if (event.type !== "response_item") return;
-    const payload = event.payload;
-    if (payload?.type !== "message" || payload?.role !== "assistant") return;
-    const blocks = Array.isArray(payload.content) ? payload.content : [];
-    for (const block of blocks) {
-      if (block.type === "output_text" && typeof block.text === "string") {
-        this.captureCompactionText(block.text);
-      }
+  // @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) {
@@ -5351,7 +5286,7 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
               this.emitQuotaStatus(snapshot);
             }
             if (isJsonlEvent2(parsed)) {
-              this.bufferCompactionFromEvent(parsed);
+              this.trackNativeCompaction(parsed);
               this.onEvent(parsed);
               emitted += 1;
             }
@@ -5384,6 +5319,574 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
   }
 };
 
+// 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);
+  }
+  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`);
+    }
+    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;
+  }
+  notify(method, params) {
+    if (this.disposed) {
+      return;
+    }
+    try {
+      this.write(params === void 0 ? { method } : { method, params });
+    } 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;
+    }
+  }
+  async loginWithConfiguredApiKey(client) {
+    if (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD !== "api_key" || !ENGINE_ENV.OPENAI_API_KEY) {
+      return;
+    }
+    const params = {
+      type: "apiKey",
+      apiKey: ENGINE_ENV.OPENAI_API_KEY
+    };
+    await client.request(ACCOUNT_LOGIN_START_METHOD, params);
+  }
+  async killAfterFailedStart() {
+    const child = this.child;
+    this.child = null;
+    this.client = null;
+    if (!child || child.killed) {
+      return;
+    }
+    this.shuttingDown = true;
+    child.kill("SIGKILL");
+    await new Promise((resolve3) => {
+      child.once("exit", () => resolve3());
+    });
+  }
+};
+
+// src/managers/codex-asp/asp-host.ts
+var hostPromise = null;
+async function getCodexAspHost() {
+  hostPromise ??= (async () => {
+    try {
+      const process2 = new AppServerProcess();
+      const { client } = await process2.start();
+      process2.on("exit", () => {
+        hostPromise = null;
+      });
+      return { client };
+    } catch (error) {
+      hostPromise = null;
+      throw error;
+    }
+  })();
+  return hostPromise;
+}
+
+// src/managers/codex-asp/codex-asp-manager.ts
+var DEFAULT_MODEL2 = "gpt-5.5";
+var THREAD_START_METHOD = "thread/start";
+var TURN_START_METHOD = "turn/start";
+var TURN_INTERRUPT_METHOD = "turn/interrupt";
+var TURN_COMPLETED_METHOD = "turn/completed";
+var ITEM_COMPLETED_METHOD = "item/completed";
+var AGENT_MESSAGE_DELTA_METHOD = "item/agentMessage/delta";
+var COMMAND_APPROVAL_METHOD = "item/commandExecution/requestApproval";
+var FILE_CHANGE_APPROVAL_METHOD = "item/fileChange/requestApproval";
+var CodexAspManager = class extends CodingAgentManager {
+  currentThreadId = null;
+  activeTurnId = null;
+  historyEvents = [];
+  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() {
+    return {
+      thread_id: this.currentThreadId,
+      events: [...this.historyEvents]
+    };
+  }
+  async processMessageInternal(request) {
+    let host = null;
+    try {
+      host = await getCodexAspHost();
+      const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
+      this.recordHistoryEvent("event_msg", {
+        type: "user_message",
+        message: request.message
+      });
+      if (!this.currentThreadId) {
+        const threadStartResponse = await host.client.request(
+          THREAD_START_METHOD,
+          await this.buildThreadStartParams(request, developerInstructions)
+        );
+        this.currentThreadId = threadStartResponse.thread.id;
+        await this.onSaveSessionId(this.currentThreadId);
+      }
+      const threadId = this.currentThreadId;
+      const completedTurn = await this.runTurn(host, threadId, request, developerInstructions);
+      if (completedTurn.status === "failed") {
+        const turnError = completedTurn.error;
+        if (!turnError) {
+          throw new Error("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}`);
+        }
+        throw new Error(parts.join(" "));
+      }
+      if (completedTurn.status === "completed") {
+        this.emitFinalAgentMessage(completedTurn);
+      }
+    } finally {
+      this.activeTurnId = null;
+      if (host?.client.isDisposed) {
+        this.currentThreadId = null;
+        void this.onSaveSessionId(null).catch(() => {
+        });
+      }
+      await this.onTurnComplete();
+    }
+  }
+  async buildThreadStartParams(request, developerInstructions) {
+    const additionalDirectories = await getAgentAdditionalDirectories();
+    return {
+      model: request.model ?? DEFAULT_MODEL2,
+      cwd: this.workingDirectory,
+      runtimeWorkspaceRoots: additionalDirectories,
+      sandbox: "danger-full-access",
+      developerInstructions: developerInstructions ?? null,
+      config: { web_search: "live" },
+      experimentalRawEvents: false,
+      persistExtendedHistory: false
+    };
+  }
+  buildTurnStartParams(threadId, request, developerInstructions) {
+    const effort = request.thinkingLevel === "max" ? "xhigh" : request.thinkingLevel;
+    const model = request.model ?? DEFAULT_MODEL2;
+    return {
+      threadId,
+      input: [{
+        type: "text",
+        text: request.message,
+        text_elements: []
+      }],
+      model,
+      ...effort ? { effort } : {},
+      ...developerInstructions ? {
+        collaborationMode: {
+          mode: "default",
+          settings: {
+            model,
+            reasoning_effort: effort ?? null,
+            developer_instructions: developerInstructions
+          }
+        }
+      } : {}
+    };
+  }
+  async runTurn(host, threadId, request, developerInstructions) {
+    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 onNotification = (notification) => {
+      if (notification.method === ITEM_COMPLETED_METHOD) {
+        if (notification.params.threadId === threadId && (!observedTurnId || notification.params.turnId === observedTurnId)) {
+          completedItems.push(notification.params.item);
+        }
+        return;
+      }
+      if (notification.method === AGENT_MESSAGE_DELTA_METHOD) {
+        if (notification.params.threadId === threadId && (!observedTurnId || notification.params.turnId === observedTurnId)) {
+          const currentText = agentMessageDeltas.get(notification.params.itemId) ?? "";
+          agentMessageDeltas.set(notification.params.itemId, currentText + notification.params.delta);
+        }
+        return;
+      }
+      if (notification.method === TURN_COMPLETED_METHOD) {
+        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
+            });
+          }
+        }
+        resolveCompleted(items.length > 0 ? { ...turn, items, itemsView: "full" } : turn);
+      }
+    };
+    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.currentThreadId = null;
+      this.activeTurnId = null;
+      void this.onSaveSessionId(null).catch(() => {
+      });
+      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 turnStartResponse = await host.client.request(
+        TURN_START_METHOD,
+        this.buildTurnStartParams(threadId, request, developerInstructions)
+      );
+      observedTurnId = turnStartResponse.turn.id;
+      this.activeTurnId = turnStartResponse.turn.id;
+      return await Promise.race([completed, disposed]);
+    } finally {
+      host.client.off("notification", onNotification);
+      host.client.off("serverRequest", onServerRequest);
+      host.client.off("dispose", onDispose);
+    }
+  }
+  emitFinalAgentMessage(turn) {
+    let text = null;
+    for (let index = turn.items.length - 1; index >= 0; index -= 1) {
+      const item = turn.items[index];
+      if (item?.type === "agentMessage") {
+        text = item.text;
+        break;
+      }
+    }
+    if (!text) {
+      return;
+    }
+    const event = this.recordHistoryEvent("response_item", {
+      type: "message",
+      role: "assistant",
+      content: [{
+        type: "output_text",
+        text
+      }]
+    });
+    this.onEvent(event);
+  }
+  recordHistoryEvent(type, payload) {
+    const event = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type,
+      payload
+    };
+    this.historyEvents.push(event);
+    return event;
+  }
+};
+
 // src/managers/relay-tools.ts
 import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
 import { z } from "zod";
@@ -6299,7 +6802,8 @@ var ChatService = class {
         codexAvailable: isCodexAvailable()
       });
     } else {
-      provider = new CodexManager({
+      const CodexProviderCtor = ENGINE_ENV.CODEX_ASP_ENABLED ? CodexAspManager : CodexManager;
+      provider = new CodexProviderCtor({
         workingDirectory: this.workingDirectory,
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
@@ -6805,7 +7309,7 @@ var PlanService = class {
 var planService = new PlanService();
 
 // src/services/warm-hooks-service.ts
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { readFile as readFile12 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
 import { join as join18 } from "path";
@@ -6973,7 +7477,7 @@ async function executeHookScriptStreaming(params) {
   params.onChunk(`$ ${params.label}
 `);
   return new Promise((resolve3) => {
-    const proc = spawn("bash", ["-lc", params.content], {
+    const proc = spawn2("bash", ["-lc", params.content], {
       cwd: params.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.212",
+  "version": "0.1.214",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",
@@ -38,6 +38,7 @@
     "zod": "^4.0.0"
   },
   "devDependencies": {
+    "@replicas/codex-asp-types": "file:../codex-asp-types",
     "@replicas/shared": "workspace:*",
     "@types/node": "^20.11.17",
     "tsup": "^8.5.0",