replicas-engine 0.1.216 → 0.1.218

package/dist/src/index.js

@@ -20,9 +20,21 @@ import { readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 
+// ../shared/src/agent.ts
+var CODEX_REASONING_EFFORT_BY_THINKING_LEVEL = {
+  low: "low",
+  medium: "medium",
+  high: "high",
+  max: "xhigh"
+};
+function codexReasoningEffortForThinkingLevel(thinkingLevel) {
+  return thinkingLevel ? CODEX_REASONING_EFFORT_BY_THINKING_LEVEL[thinkingLevel] : void 0;
+}
+
 // ../shared/src/event.ts
 var CODEX_QUOTA_STATUS_EVENT_TYPE = "codex-quota-status";
 var COMPACTION_STATUS_EVENT_TYPE = "compaction-status";
+var CHAT_GOAL_EVENT_TYPE = "chat-goal";
 var CONTEXT_USAGE_EVENT_TYPE = "context-usage";
 
 // ../shared/src/languages.ts
@@ -115,6 +127,10 @@ function detectLanguageByPath(filePath) {
 }
 
 // ../shared/src/context-usage.ts
+var CODEX_CATEGORY_COLORS = {
+  input: "#66bb6a",
+  output: "#56b6c2"
+};
 function clampPercentage(value) {
   if (!Number.isFinite(value)) return 0;
   if (value < 0) return 0;
@@ -130,6 +146,54 @@ function clampTokensToWindow(rawTokens, maxTokens) {
   if (rawTokens <= maxTokens) return { totalTokens: rawTokens };
   return { totalTokens: maxTokens, totalProcessedTokens: rawTokens };
 }
+function compactCategories(categories) {
+  return categories.filter((category) => Boolean(category && category.tokens > 0)).map((category) => ({
+    ...category,
+    percentage: clampPercentage(category.percentage)
+  }));
+}
+function buildCodexTokenUsageContextUsagePayload(usage) {
+  const maxTokens = usage.modelContextWindow;
+  const inputTokens = usage.last.inputTokens;
+  const outputTokens = usage.last.outputTokens;
+  const lastTurnTokens = usage.last.totalTokens;
+  const { totalTokens } = clampTokensToWindow(lastTurnTokens, maxTokens);
+  const cumulativeTotalTokens = usage.total?.totalTokens ?? null;
+  const totalProcessedTokens = cumulativeTotalTokens !== null && cumulativeTotalTokens > totalTokens ? cumulativeTotalTokens : clampTokensToWindow(lastTurnTokens, maxTokens).totalProcessedTokens;
+  return {
+    provider: "codex",
+    source: "codex_token_count",
+    ...usage.model !== void 0 ? { model: usage.model } : {},
+    totalTokens,
+    ...totalProcessedTokens !== void 0 ? { totalProcessedTokens } : {},
+    maxTokens,
+    rawMaxTokens: maxTokens,
+    percentage: percentage(totalTokens, maxTokens),
+    compactsAutomatically: true,
+    categories: compactCategories([
+      {
+        name: "Input context",
+        tokens: inputTokens,
+        percentage: percentage(inputTokens, maxTokens),
+        color: CODEX_CATEGORY_COLORS.input
+      },
+      {
+        name: "Generated output",
+        tokens: outputTokens,
+        percentage: percentage(outputTokens, maxTokens),
+        color: CODEX_CATEGORY_COLORS.output
+      }
+    ]),
+    apiUsage: {
+      inputTokens,
+      outputTokens,
+      ...usage.last.cachedInputTokens !== null && usage.last.cachedInputTokens !== void 0 ? { cachedInputTokens: usage.last.cachedInputTokens } : {},
+      ...usage.last.reasoningOutputTokens !== null && usage.last.reasoningOutputTokens !== void 0 ? { reasoningOutputTokens: usage.last.reasoningOutputTokens } : {},
+      ...cumulativeTotalTokens !== null ? { totalTokens: cumulativeTotalTokens } : {}
+    },
+    updatedAt: usage.updatedAt
+  };
+}
 
 // ../shared/src/pricing.ts
 var PLANS = {
@@ -1565,6 +1629,15 @@ var DEFAULT_DEFAULT_SKILLS = {
   }
 };
 
+// ../shared/src/prompts.ts
+function parseGoalCommand(message) {
+  const match = message.trim().match(/^\/goal(?:\s+([\s\S]*))?$/i);
+  const value = match?.[1]?.trim();
+  if (!value) return null;
+  if (/^(clear|reset|unset)$/i.test(value)) return { type: "clear" };
+  return { type: "set", objective: value };
+}
+
 // ../shared/src/replicas-config.ts
 import { parse as parseYaml } from "yaml";
 
@@ -1686,7 +1759,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "26-05-2026-royal-york-v3";
+var DAYTONA_SNAPSHOT_ID = "26-05-2026-royal-york-v5";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -3548,19 +3621,19 @@ var previewService = new PreviewService();
 
 // src/services/chat/chat-service.ts
 import { existsSync as existsSync7 } from "fs";
-import { appendFile as appendFile5, mkdir as mkdir10, readFile as readFile8, rm, writeFile as writeFile8 } from "fs/promises";
-import { homedir as homedir12 } from "os";
-import { join as join14 } from "path";
+import { appendFile as appendFile5, mkdir as mkdir11, readFile as readFile8, rm, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir13 } from "os";
+import { join as join15 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/managers/claude-manager.ts
 import {
   query
 } from "@anthropic-ai/claude-agent-sdk";
-import { randomUUID as randomUUID3 } from "crypto";
-import { join as join12 } from "path";
-import { mkdir as mkdir8, appendFile as appendFile4 } from "fs/promises";
-import { homedir as homedir10 } from "os";
+import { randomUUID as randomUUID4 } from "crypto";
+import { join as join13 } from "path";
+import { mkdir as mkdir9, appendFile as appendFile4 } from "fs/promises";
+import { homedir as homedir11 } from "os";
 
 // src/utils/jsonl-reader.ts
 import { readFile as readFile6 } from "fs/promises";
@@ -3593,33 +3666,6 @@ async function readJSONL(filePath) {
   }
 }
 
-// src/services/monolith-service.ts
-var MonolithService = class {
-  async sendEvent(event) {
-    if (!ENGINE_ENV.WORKSPACE_ID) {
-      return;
-    }
-    try {
-      const response = await fetch(`${ENGINE_ENV.MONOLITH_URL}/v1/engine/webhook`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${ENGINE_ENV.REPLICAS_ENGINE_SECRET}`,
-          "X-Workspace-Id": ENGINE_ENV.WORKSPACE_ID,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify(event)
-      });
-      if (!response.ok) {
-        const errorText = await response.text();
-        console.error(`[MonolithService] Failed to send event: ${response.status} ${errorText}`);
-      }
-    } catch (error) {
-      console.error("[MonolithService] Failed to send event:", error);
-    }
-  }
-};
-var monolithService = new MonolithService();
-
 // src/utils/linear-converter.ts
 function linearThoughtToResponse(thought) {
   return {
@@ -3999,8 +4045,138 @@ function extractPlanFromCodexEvent(event) {
     status: entry.completed ? "completed" : hasIncomplete ? "inProgress" : "pending"
   }));
 }
+function codexAspReasoningText(item) {
+  return [...item.summary, ...item.content].filter(Boolean).join("\n").trim();
+}
+function codexAspChangePaths(item) {
+  return item.changes.map((change) => change.path).filter(Boolean).join(", ");
+}
+function codexAspStatusResult(status) {
+  return status === "completed" ? "Done" : status || "Done";
+}
+function convertCodexAspItem(item, lifecycle, linearSessionId) {
+  if (item.type === "agentMessage") {
+    if (!item.text) return null;
+    return {
+      linearSessionId,
+      content: {
+        type: "thought",
+        body: item.text
+      }
+    };
+  }
+  if (item.type === "reasoning") {
+    const text = codexAspReasoningText(item);
+    if (!text) return null;
+    return {
+      linearSessionId,
+      content: {
+        type: "thought",
+        body: text
+      }
+    };
+  }
+  if (item.type === "commandExecution") {
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: "Running command",
+        parameter: item.command,
+        ...lifecycle === "completed" ? { result: item.exitCode !== null ? `Exit code: ${item.exitCode}` : item.aggregatedOutput || "Done" } : {}
+      }
+    };
+  }
+  if (item.type === "fileChange") {
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: "File change",
+        parameter: codexAspChangePaths(item),
+        ...lifecycle === "completed" ? { result: codexAspStatusResult(item.status) } : {}
+      }
+    };
+  }
+  if (item.type === "mcpToolCall") {
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: item.tool || "MCP tool call",
+        parameter: item.server,
+        ...lifecycle === "completed" ? { result: item.error?.message ?? codexAspStatusResult(item.status) } : {}
+      }
+    };
+  }
+  if (item.type === "dynamicToolCall") {
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: item.tool,
+        parameter: item.namespace ?? "",
+        ...lifecycle === "completed" ? { result: item.success === false ? "Failed" : codexAspStatusResult(item.status) } : {}
+      }
+    };
+  }
+  if (item.type === "webSearch") {
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: "Web search",
+        parameter: item.query,
+        ...lifecycle === "completed" ? { result: "Done" } : {}
+      }
+    };
+  }
+  if (item.type === "plan") {
+    return {
+      linearSessionId,
+      content: {
+        type: "action",
+        action: "Updating plan",
+        parameter: item.text,
+        ...lifecycle === "completed" ? { result: "Done" } : {}
+      }
+    };
+  }
+  return null;
+}
+function convertCodexAspNotification(notification, linearSessionId) {
+  if (notification.method === "turn/started") {
+    return {
+      linearSessionId,
+      content: {
+        type: "thought",
+        body: "Processing..."
+      }
+    };
+  }
+  if (notification.method === "item/started") {
+    return convertCodexAspItem(notification.params.item, "started", linearSessionId);
+  }
+  if (notification.method === "item/completed") {
+    return convertCodexAspItem(notification.params.item, "completed", linearSessionId);
+  }
+  return null;
+}
+function extractPlanFromCodexAspNotification(notification) {
+  if (notification.method !== "turn/plan/updated" || notification.params.plan.length === 0) {
+    return null;
+  }
+  return notification.params.plan.filter((item) => item.step.trim().length > 0).map((item) => ({
+    content: item.step.trim(),
+    status: item.status
+  }));
+}
 
 // src/utils/image-utils.ts
+import { randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir8, unlink as unlink2, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir10 } from "os";
+import { join as join12 } from "path";
 function isImageMediaType(value) {
   return IMAGE_MEDIA_TYPES.includes(value);
 }
@@ -4078,6 +4254,26 @@ async function normalizeImages(images) {
   }
   return normalized;
 }
+async function saveNormalizedImagesToTempFiles(images, tempImageDir = join12(homedir10(), ".replicas", "codex", "temp-images")) {
+  await mkdir8(tempImageDir, { recursive: true });
+  const tempPaths = [];
+  try {
+    for (const image of images) {
+      const ext = image.source.media_type.split("/")[1] || "png";
+      const filename = `img_${randomUUID3()}.${ext}`;
+      const filepath = join12(tempImageDir, filename);
+      await writeFile7(filepath, Buffer.from(image.source.data, "base64"));
+      tempPaths.push(filepath);
+    }
+  } catch (error) {
+    await removeTempImageFiles(tempPaths);
+    throw error;
+  }
+  return tempPaths;
+}
+async function removeTempImageFiles(paths) {
+  await Promise.allSettled(paths.map((path4) => unlink2(path4)));
+}
 
 // src/services/message-queue-service.ts
 var MessageQueueService = class {
@@ -4216,6 +4412,33 @@ var MessageQueueService = class {
   }
 };
 
+// src/services/monolith-service.ts
+var MonolithService = class {
+  async sendEvent(event) {
+    if (!ENGINE_ENV.WORKSPACE_ID) {
+      return;
+    }
+    try {
+      const response = await fetch(`${ENGINE_ENV.MONOLITH_URL}/v1/engine/webhook`, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${ENGINE_ENV.REPLICAS_ENGINE_SECRET}`,
+          "X-Workspace-Id": ENGINE_ENV.WORKSPACE_ID,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(event)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`[MonolithService] Failed to send event: ${response.status} ${errorText}`);
+      }
+    } catch (error) {
+      console.error("[MonolithService] Failed to send event:", error);
+    }
+  }
+};
+var monolithService = new MonolithService();
+
 // src/managers/coding-agent-manager.ts
 var MAX_INTERRUPT_QUEUE_ITEMS = 1e3;
 var MAX_INTERRUPT_QUEUE_CHARS = 2e5;
@@ -4425,6 +4648,49 @@ async function getAgentAdditionalDirectories() {
   }
 }
 
+// src/utils/linear-event-forwarder.ts
+function isLinearThoughtEvent(event) {
+  return event.content.type === "thought";
+}
+var LinearEventForwarder = class {
+  linearSessionId;
+  latestThoughtEvent = null;
+  constructor(linearSessionId) {
+    this.linearSessionId = linearSessionId;
+  }
+  sendPlan(plan) {
+    if (!this.linearSessionId || !plan) return;
+    monolithService.sendEvent({
+      type: "agent_plan_update",
+      payload: { linearSessionId: this.linearSessionId, plan }
+    }).catch(() => {
+    });
+  }
+  sendEvent(linearEvent) {
+    if (!this.linearSessionId || !linearEvent) return;
+    if (this.latestThoughtEvent) {
+      monolithService.sendEvent({ type: "agent_update", payload: this.latestThoughtEvent }).catch(() => {
+      });
+    }
+    if (isLinearThoughtEvent(linearEvent)) {
+      this.latestThoughtEvent = linearEvent;
+      return;
+    }
+    this.latestThoughtEvent = null;
+    monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
+    });
+  }
+  flushThoughtAsResponse() {
+    if (!this.linearSessionId || !this.latestThoughtEvent) return;
+    monolithService.sendEvent({
+      type: "agent_update",
+      payload: linearThoughtToResponse(this.latestThoughtEvent)
+    }).catch(() => {
+    });
+    this.latestThoughtEvent = null;
+  }
+};
+
 // src/managers/claude-manager.ts
 var PromptStream = class {
   queue = [];
@@ -4464,9 +4730,6 @@ var PromptStream = class {
     };
   }
 };
-function isLinearThoughtEvent(event) {
-  return event.content.type === "thought";
-}
 var ALWAYS_ALLOWED_TOOLS = [
   "Read",
   "Glob",
@@ -4589,7 +4852,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
   pendingToolInputs = /* @__PURE__ */ new Map();
   constructor(options) {
     super(options);
-    this.historyFile = options.historyFilePath ?? join12(homedir10(), ".replicas", "claude", "history.jsonl");
+    this.historyFile = options.historyFilePath ?? join13(homedir11(), ".replicas", "claude", "history.jsonl");
     this.systemPromptOverride = options.systemPromptOverride;
     this.toolsOverride = options.tools;
     this.mcpServersConfig = options.mcpServers;
@@ -4653,7 +4916,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
       if (!handler) {
         return { behavior: "allow" };
       }
-      const requestId = randomUUID3();
+      const requestId = randomUUID4();
       const toolUseId = options.toolUseID;
       const { options: requestOptions, questions: requestQuestions } = handler.getRequest(input);
       const result = await new Promise((resolve3) => {
@@ -4813,32 +5076,12 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
         this.activePromptStream?.close();
         await this.activeQuery.interrupt();
       }
-      let latestThoughtEvent = null;
+      const linearForwarder = new LinearEventForwarder(linearSessionId);
       for await (const msg of response) {
         await this.handleMessage(msg);
         if (linearSessionId) {
-          const plan = extractPlanFromClaudeEvent(msg);
-          if (plan) {
-            monolithService.sendEvent({
-              type: "agent_plan_update",
-              payload: { linearSessionId, plan }
-            }).catch(() => {
-            });
-          }
-          const linearEvent = convertClaudeEvent(msg, linearSessionId);
-          if (linearEvent) {
-            if (latestThoughtEvent) {
-              monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
-              });
-            }
-            if (isLinearThoughtEvent(linearEvent)) {
-              latestThoughtEvent = linearEvent;
-            } else {
-              latestThoughtEvent = null;
-              monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
-              });
-            }
-          }
+          linearForwarder.sendPlan(extractPlanFromClaudeEvent(msg));
+          linearForwarder.sendEvent(convertClaudeEvent(msg, linearSessionId));
         }
         if (msg.type === "result") {
           await this.recordContextUsage(response);
@@ -4846,11 +5089,7 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
           break;
         }
       }
-      if (linearSessionId && latestThoughtEvent) {
-        const responseEvent = linearThoughtToResponse(latestThoughtEvent);
-        monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
-        });
-      }
+      linearForwarder.flushThoughtAsResponse();
     } finally {
       this.activeQuery = null;
       this.activePromptStream?.close();
@@ -4927,8 +5166,8 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
     };
   }
   async initialize() {
-    const historyDir = join12(homedir10(), ".replicas", "claude");
-    await mkdir8(historyDir, { recursive: true });
+    const historyDir = join13(homedir11(), ".replicas", "claude");
+    await mkdir9(historyDir, { recursive: true });
     if (this.initialSessionId) {
       this.sessionId = this.initialSessionId;
       console.log(`[ClaudeManager] Restored session ID from persisted state: ${this.sessionId}`);
@@ -4990,27 +5229,29 @@ var ClaudeManager = class _ClaudeManager extends CodingAgentManager {
 
 // src/managers/codex-manager.ts
 import { Codex } from "@openai/codex-sdk";
-import { randomUUID as randomUUID4 } from "crypto";
-import { readdir as readdir3, stat as stat2, writeFile as writeFile7, mkdir as mkdir9, readFile as readFile7 } from "fs/promises";
+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 join13 } from "path";
-import { homedir as homedir11 } from "os";
+import { join as join14 } from "path";
+import { homedir as homedir12 } from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-var DEFAULT_MODEL = "gpt-5.5";
-var CODEX_CONFIG_PATH = join13(homedir11(), ".codex", "config.toml");
-function isLinearThoughtEvent2(event) {
-  return event.content.type === "thought";
-}
-function isJsonlEvent2(value) {
-  if (!isRecord3(value)) {
-    return false;
+
+// 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 typeof value.timestamp === "string" && typeof value.type === "string" && isRecord3(value.payload);
-}
-function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return {
+    state,
+    balance: fields.balance,
+    rateLimitResetType: fields.rateLimitResetType,
+    planType: fields.planType
+  };
 }
-function extractRateLimitsSnapshot(parsed) {
+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;
@@ -5019,60 +5260,100 @@ function extractRateLimitsSnapshot(parsed) {
   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;
-  if (unlimited === true) return 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;
-  let state = "ok";
-  if (hasCredits === false) {
-    state = "out_of_credits";
-  } else if (rateLimitResetType !== null) {
-    state = "rate_limited";
-  }
-  return { state, balance, rateLimitResetType, planType };
+  return buildCodexRateLimitsSnapshot({
+    unlimited,
+    hasCredits,
+    balance,
+    rateLimitResetType,
+    planType
+  });
 }
-var CodexManager = class _CodexManager extends CodingAgentManager {
-  codex;
-  currentThreadId = null;
-  currentThread = null;
-  tempImageDir;
-  activeAbortController = null;
-  /** Most recent quota state observed from a rollout `rate_limits` payload. */
-  latestQuotaState = "ok";
-  /** Last state actually emitted to the UI. Drives dedup so seeded historical state still emits the first time it surfaces in a turn. */
+var CodexQuotaStatusTracker = class {
   lastEmittedQuotaState = "ok";
-  /** Last full snapshot, retained so we can re-emit when a user retries while blocked. */
   latestQuotaSnapshot = null;
-  /** When true, new turns short-circuit instead of running. Set by `out_of_credits`. */
   quotaBlocked = false;
-  constructor(options) {
-    super(options);
-    this.codex = this.createCodexClient();
-    this.tempImageDir = join13(homedir11(), ".replicas", "codex", "temp-images");
-    this.initializeManager(this.processMessageInternal.bind(this));
+  get blocked() {
+    return this.quotaBlocked;
   }
-  createCodexClient() {
-    const codexApiKey = resolveCodexApiKey();
-    return new Codex({
-      env: buildCodexAgentEnv(),
-      ...codexApiKey ? { apiKey: codexApiKey } : {}
-    });
+  get latestSnapshot() {
+    return this.latestQuotaSnapshot;
   }
-  resetCodexClient() {
-    this.codex = this.createCodexClient();
-    this.currentThread = null;
+  prime(snapshot) {
+    this.latestQuotaSnapshot = snapshot;
+    this.quotaBlocked = snapshot.state === "out_of_credits";
   }
-  async initialize() {
-    if (this.initialSessionId) {
-      this.currentThreadId = this.initialSessionId;
-      console.log(`[CodexManager] Restored thread ID from persisted state: ${this.currentThreadId}`);
+  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-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;
+  }
+  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));
+  }
+  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}`);
     }
   }
-  /**
-   * One-shot pass over the current session's rollout jsonl to find the most
-   * recent `rate_limits` entry and emit a quota state if it has changed.
-   * Used after `runStreamed` throws — the tail loop may not have pumped the
-   * fatal line before the SDK exited.
-   */
   async flushQuotaSnapshotFromCurrentSession() {
     if (!this.currentThreadId) return;
     try {
@@ -5084,7 +5365,7 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
-          const snapshot = extractRateLimitsSnapshot(parsed);
+          const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
           if (snapshot) {
             latest = snapshot;
           }
@@ -5098,41 +5379,9 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
       console.warn("[CodexManager] Failed to flush quota snapshot from session:", error);
     }
   }
-  /**
-   * Emit a synthetic codex-quota-status AgentEvent and update local state.
-   * Dedupes against `lastEmittedQuotaState` (what the UI has actually seen),
-   * not `latestQuotaState`, so a state primed silently by `seedSeenLines` on
-   * engine restart still emits the first time it surfaces in a turn. Pass
-   * `force` to re-emit on a retry so users see the banner reappear.
-   */
   emitQuotaStatus(snapshot, force = false) {
-    const stateChanged = snapshot.state !== this.lastEmittedQuotaState;
-    if (!stateChanged && !force) {
-      return;
-    }
-    this.latestQuotaState = snapshot.state;
-    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
-    };
-    this.onEvent({
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      type: CODEX_QUOTA_STATUS_EVENT_TYPE,
-      payload
-    });
-    if (!stateChanged) return;
-    if (snapshot.state === "out_of_credits") {
-      console.warn("[CodexManager] Codex account out of credits \u2014 pausing turn processing.");
-    } else if (snapshot.state === "rate_limited") {
-      console.warn(`[CodexManager] Codex rate limit reached (${snapshot.rateLimitResetType}).`);
-    } else {
-      console.log("[CodexManager] Codex quota recovered.");
-    }
+    const event = this.quotaStatus.apply(snapshot, force);
+    if (event) this.onEvent(event);
   }
   async interruptActiveTurn() {
     if (this.activeAbortController) {
@@ -5145,8 +5394,8 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
    */
   async updateCodexConfig(developerInstructions) {
     try {
-      const codexDir = join13(homedir11(), ".codex");
-      await mkdir9(codexDir, { recursive: true });
+      const codexDir = join14(homedir12(), ".codex");
+      await mkdir10(codexDir, { recursive: true });
       let config = {};
       if (existsSync6(CODEX_CONFIG_PATH)) {
         try {
@@ -5165,34 +5414,17 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
         delete config.developer_instructions;
       }
       const tomlContent = stringifyToml(config);
-      await writeFile7(CODEX_CONFIG_PATH, tomlContent, "utf-8");
+      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);
     }
   }
-  /**
-   * Helper method to save normalized images to temp files for Codex SDK
-   * @returns Array of temp file paths
-   */
-  async saveImagesToTempFiles(images) {
-    await mkdir9(this.tempImageDir, { recursive: true });
-    const tempPaths = [];
-    for (const image of images) {
-      const ext = image.source.media_type.split("/")[1] || "png";
-      const filename = `img_${randomUUID4()}.${ext}`;
-      const filepath = join13(this.tempImageDir, filename);
-      const buffer = Buffer.from(image.source.data, "base64");
-      await writeFile7(filepath, buffer);
-      tempPaths.push(filepath);
-    }
-    return tempPaths;
-  }
   async processMessageInternal(request) {
     try {
       await this.executeCodexTurn(request);
     } catch (error) {
-      if (_CodexManager.isAuthError(error)) {
+      if (isCodexAuthError(error)) {
         const refreshed = await codexTokenManager.fetchFreshCredentials(error instanceof Error ? error.message : String(error));
         if (refreshed) {
           this.resetCodexClient();
@@ -5204,10 +5436,10 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
     }
   }
   async executeCodexTurn(request) {
-    if (this.quotaBlocked && this.latestQuotaSnapshot) {
+    if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
       await this.flushQuotaSnapshotFromCurrentSession();
-      if (this.quotaBlocked && this.latestQuotaSnapshot) {
-        this.emitQuotaStatus(this.latestQuotaSnapshot, true);
+      if (this.quotaStatus.blocked && this.quotaStatus.latestSnapshot) {
+        this.emitQuotaStatus(this.quotaStatus.latestSnapshot, true);
         try {
           await this.onTurnComplete();
         } catch (error) {
@@ -5231,13 +5463,13 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
     try {
       if (images && images.length > 0) {
         const normalizedImages = await normalizeImages(images);
-        tempImagePaths = await this.saveImagesToTempFiles(normalizedImages);
+        tempImagePaths = await saveNormalizedImagesToTempFiles(normalizedImages);
       }
       const developerInstructions = this.buildCombinedInstructions(customInstructions);
       await this.updateCodexConfig(developerInstructions);
       const sandboxMode = "danger-full-access";
       const webSearchMode = "live";
-      const codexReasoningEffort = thinkingLevel ? thinkingLevel === "max" ? "xhigh" : thinkingLevel : void 0;
+      const codexReasoningEffort = codexReasoningEffortForThinkingLevel(thinkingLevel);
       const additionalDirectories = await getAgentAdditionalDirectories();
       const threadOptions = {
         workingDirectory: this.workingDirectory,
@@ -5281,42 +5513,17 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
       }
       try {
         const { events } = await this.currentThread.runStreamed(input, { signal: abortController.signal });
-        let latestThoughtEvent = null;
+        const linearForwarder = new LinearEventForwarder(linearSessionId);
         for await (const event of events) {
           if (linearSessionId) {
-            const plan = extractPlanFromCodexEvent(event);
-            if (plan) {
-              monolithService.sendEvent({
-                type: "agent_plan_update",
-                payload: { linearSessionId, plan }
-              }).catch(() => {
-              });
-            }
-            const linearEvent = convertCodexEvent(event, linearSessionId);
-            if (linearEvent) {
-              if (latestThoughtEvent) {
-                monolithService.sendEvent({ type: "agent_update", payload: latestThoughtEvent }).catch(() => {
-                });
-              }
-              if (isLinearThoughtEvent2(linearEvent)) {
-                latestThoughtEvent = linearEvent;
-              } else {
-                latestThoughtEvent = null;
-                monolithService.sendEvent({ type: "agent_update", payload: linearEvent }).catch(() => {
-                });
-              }
-            }
+            linearForwarder.sendPlan(extractPlanFromCodexEvent(event));
+            linearForwarder.sendEvent(convertCodexEvent(event, linearSessionId));
           }
         }
-        if (linearSessionId && latestThoughtEvent) {
-          const responseEvent = linearThoughtToResponse(latestThoughtEvent);
-          monolithService.sendEvent({ type: "agent_update", payload: responseEvent }).catch(() => {
-          });
-        }
+        linearForwarder.flushThoughtAsResponse();
       } catch (error) {
         await this.flushQuotaSnapshotFromCurrentSession();
-        if (this.quotaBlocked) {
-          console.warn("[CodexManager] runStreamed failed while quota was blocked \u2014 surfacing as quota state.");
+        if (this.quotaStatus.blocked) {
           return;
         }
         throw error;
@@ -5325,6 +5532,7 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
       if (stopTail) {
         await stopTail();
       }
+      await removeTempImageFiles(tempImagePaths);
       try {
         await this.onTurnComplete();
       } catch (error) {
@@ -5333,11 +5541,6 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
       this.activeAbortController = null;
     }
   }
-  static isAuthError(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("login") || lower.includes("401");
-  }
   async getHistory() {
     if (!this.currentThreadId) {
       return {
@@ -5360,13 +5563,13 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
   }
   // Helper methods for finding session files
   async findSessionFile(threadId) {
-    const sessionsDir = join13(homedir11(), ".codex", "sessions");
+    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 = join13(sessionsDir, String(year), month, day);
+      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++) {
@@ -5375,7 +5578,7 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
         const searchYear = date.getFullYear();
         const searchMonth = String(date.getMonth() + 1).padStart(2, "0");
         const searchDay = String(date.getDate()).padStart(2, "0");
-        const searchDir = join13(sessionsDir, String(searchYear), searchMonth, searchDay);
+        const searchDir = join14(sessionsDir, String(searchYear), searchMonth, searchDay);
         const file2 = await this.findFileInDirectory(searchDir, threadId);
         if (file2) return file2;
       }
@@ -5389,7 +5592,7 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
       const files = await readdir3(directory);
       for (const file of files) {
         if (file.endsWith(".jsonl") && file.includes(threadId)) {
-          const fullPath = join13(directory, file);
+          const fullPath = join14(directory, file);
           const stats = await stat2(fullPath);
           if (stats.isFile()) {
             return fullPath;
@@ -5446,15 +5649,13 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
           seenLines.add(line);
           try {
             const parsed = JSON.parse(line);
-            const snapshot = extractRateLimitsSnapshot(parsed);
+            const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
             if (snapshot) latest = snapshot;
           } catch {
           }
         }
         if (latest) {
-          this.latestQuotaState = latest.state;
-          this.latestQuotaSnapshot = latest;
-          this.quotaBlocked = latest.state === "out_of_credits";
+          this.quotaStatus.prime(latest);
         }
       } catch {
       }
@@ -5474,7 +5675,7 @@ var CodexManager = class _CodexManager extends CodingAgentManager {
           seenLines.add(trimmed);
           try {
             const parsed = JSON.parse(trimmed);
-            const snapshot = extractRateLimitsSnapshot(parsed);
+            const snapshot = extractCodexRateLimitsSnapshotFromJsonl(parsed);
             if (snapshot) {
               this.emitQuotaStatus(snapshot);
             }
@@ -5787,6 +5988,26 @@ var AppServerProcess = class {
       throw error;
     }
   }
+  async stop() {
+    const child = this.child;
+    this.shuttingDown = true;
+    this.client?.dispose(new Error("ASP process stopped"));
+    this.client = null;
+    this.child = null;
+    if (!child || child.killed) {
+      return;
+    }
+    await new Promise((resolve3) => {
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+      }, 2e3);
+      child.once("exit", () => {
+        clearTimeout(timer);
+        resolve3();
+      });
+      child.kill("SIGTERM");
+    });
+  }
   async loginWithConfiguredApiKey(client) {
     if (ENGINE_ENV.REPLICAS_CODEX_AUTH_METHOD !== "api_key" || !ENGINE_ENV.OPENAI_API_KEY) {
       return;
@@ -5814,12 +6035,21 @@ var AppServerProcess = class {
 
 // src/managers/codex-asp/asp-host.ts
 var hostPromise = null;
+var activeProcess = null;
+var restartPromise = null;
 async function getCodexAspHost() {
+  if (restartPromise) {
+    await restartPromise;
+  }
   hostPromise ??= (async () => {
     try {
       const process2 = new AppServerProcess();
       const { client } = await process2.start();
+      activeProcess = process2;
       process2.on("exit", () => {
+        if (activeProcess === process2) {
+          activeProcess = null;
+        }
         hostPromise = null;
       });
       return { client };
@@ -5830,21 +6060,332 @@ async function getCodexAspHost() {
   })();
   return hostPromise;
 }
+async function restartCodexAspHost() {
+  if (restartPromise) {
+    return restartPromise;
+  }
+  restartPromise = (async () => {
+    const process2 = activeProcess;
+    hostPromise = null;
+    activeProcess = null;
+    if (process2) {
+      await process2.stop();
+    }
+  })();
+  try {
+    await restartPromise;
+  } finally {
+    restartPromise = null;
+  }
+}
 
-// src/managers/codex-asp/codex-asp-manager.ts
+// 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";
+  }
+  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 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}`);
+    } else {
+      lines.push(`*** Update File: ${change.path}`);
+      if (change.kind.move_path) {
+        lines.push(`*** Move to: ${change.kind.move_path}`);
+      }
+    }
+    if (change.diff.trim().length > 0) {
+      lines.push(change.diff);
+    }
+  }
+  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
+        }]
+      }
+    }];
+  }
+  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
+      }
+    }];
+  }
+  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)
+      }
+    }];
+  }
+  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"
+        }
+      }];
+    }
+    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"
+        }
+      }];
+    }
+    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 }
+        })
+      }
+    }];
+  }
+  return [];
+}
+function threadToHistoryEvents(thread) {
+  const events = [];
+  for (const turn of thread.turns) {
+    const startedAt = timestampFromSeconds(turn.startedAt);
+    const completedAt = timestampFromSeconds(turn.completedAt ?? turn.startedAt);
+    for (const item of turn.items) {
+      if (item.type === "userMessage") {
+        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 }
+          });
+        }
+        continue;
+      }
+      for (const draft of itemToAgentEventDrafts(item, "started")) {
+        events.push({ timestamp: startedAt, ...draft });
+      }
+      for (const draft of itemToAgentEventDrafts(item, "completed")) {
+        events.push({ timestamp: completedAt, ...draft });
+      }
+    }
+  }
+  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: [] };
+  }
+  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);
+}
+
+// src/managers/codex-asp/codex-asp-manager.ts
 var CodexAspManager = class extends CodingAgentManager {
   currentThreadId = null;
   activeTurnId = null;
+  threadAttached = false;
   historyEvents = [];
+  emittedItemStages = /* @__PURE__ */ new Set();
+  quotaStatus = new CodexQuotaStatusTracker();
+  currentGoal = null;
   constructor(options) {
     super(options);
     this.initializeManager(this.processMessageInternal.bind(this));
@@ -5870,95 +6411,172 @@ var CodexAspManager = class extends CodingAgentManager {
     }
   }
   async getHistory() {
+    if (!this.currentThreadId) {
+      return { thread_id: null, events: [], goal: null };
+    }
+    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 = threadToHistoryEvents(response.thread);
+      if (events.length > 0) {
+        const supplementalEvents = this.historyEvents.filter((event) => event.type === CODEX_QUOTA_STATUS_EVENT_TYPE || event.type === CONTEXT_USAGE_EVENT_TYPE || event.type === CHAT_GOAL_EVENT_TYPE || event.type === "event_msg" && event.payload.command === "goal");
+        return {
+          thread_id: this.currentThreadId,
+          events: [...events, ...supplementalEvents].sort((a, b) => a.timestamp.localeCompare(b.timestamp)),
+          goal: this.currentGoal
+        };
+      }
+    } catch {
+    }
     return {
       thread_id: this.currentThreadId,
-      events: [...this.historyEvents]
+      events: [...this.historyEvents],
+      goal: this.currentGoal
     };
   }
+  getGoal() {
+    return this.currentGoal;
+  }
   async processMessageInternal(request) {
-    let host = null;
-    try {
-      host = await getCodexAspHost();
-      const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
+    let userMessageRecorded = false;
+    const recordUserMessage = (extraPayload = {}) => {
+      if (userMessageRecorded) return;
+      userMessageRecorded = true;
       this.recordHistoryEvent("event_msg", {
         type: "user_message",
-        message: request.message
+        message: request.message,
+        ...extraPayload
       });
-      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 goalCommand = parseGoalCommand(request.message);
+    const dispatch = async () => {
+      if (goalCommand?.type === "clear") {
+        await this.executeGoalClearCommand(request, recordUserMessage);
+        return;
       }
-      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 (goalCommand?.type === "set") {
+        await this.executeAspTurn(request, recordUserMessage, {
+          runTurn: (host, threadId) => this.runGoalTurn(host, threadId, request, goalCommand.objective),
+          userMessagePayload: { command: "goal" }
+        });
+        return;
       }
-      if (completedTurn.status === "completed") {
-        this.emitFinalAgentMessage(completedTurn);
+      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;
-      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
-    };
+  async executeGoalClearCommand(request, recordUserMessage) {
+    const host = await getCodexAspHost();
+    const developerInstructions = this.buildCombinedInstructions(request.customInstructions);
+    const threadId = await this.ensureThread(host, request, developerInstructions);
+    recordUserMessage({ command: "goal" });
+    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);
+    const threadId = await this.ensureThread(host, request, developerInstructions);
+    recordUserMessage(options.userMessagePayload);
+    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);
+    }
   }
-  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 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;
+    }
+    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;
@@ -5973,24 +6591,66 @@ var CodexAspManager = class extends CodingAgentManager {
     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);
+    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);
         }
-        return;
-      }
-      if (notification.method === TURN_COMPLETED_METHOD) {
-        if (notification.params.threadId !== threadId) {
-          return;
+        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] : [];
@@ -6015,6 +6675,9 @@ var CodexAspManager = class extends CodingAgentManager {
         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;
@@ -6023,10 +6686,8 @@ var CodexAspManager = class extends CodingAgentManager {
       host.client.respond(serverRequest.id, { decision: "accept" });
     };
     const onDispose = (reason) => {
-      this.currentThreadId = null;
+      this.threadAttached = false;
       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}`));
     };
@@ -6034,41 +6695,88 @@ var CodexAspManager = class extends CodingAgentManager {
     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]);
+      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;
+      }
     }
   }
-  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;
+  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"));
+    }
+    this.emittedItemStages.add(stageKey);
+    this.recordAndEmitDrafts(itemToAgentEventDrafts(item, lifecycle));
+  }
+  emitTurnCompletedItems(turn) {
+    for (const item of turn.items) {
+      this.emitThreadItemLifecycle(item, "completed");
+    }
+  }
+  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 })
       }
+    }]);
+  }
+  seedHistoryFromThread(thread) {
+    const events = threadToHistoryEvents(thread);
+    if (events.length === 0) return;
+    this.historyEvents.splice(0, this.historyEvents.length, ...events);
+  }
+  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);
     }
-    if (!text) {
+  }
+  recordGoalChange(goal, force = false) {
+    const nextGoal = goal ? aspGoalToChatGoal(goal) : null;
+    if (!force && JSON.stringify(this.currentGoal) === JSON.stringify(nextGoal)) {
       return;
     }
-    const event = this.recordHistoryEvent("response_item", {
-      type: "message",
-      role: "assistant",
-      content: [{
-        type: "output_text",
-        text
-      }]
-    });
+    this.currentGoal = nextGoal;
+    const event = this.recordHistoryEvent(
+      CHAT_GOAL_EVENT_TYPE,
+      { goal: nextGoal }
+    );
     this.onEvent(event);
   }
+  recordAndEmitDrafts(drafts) {
+    for (const draft of drafts) {
+      const event = this.recordHistoryEvent(draft.type, draft.payload);
+      this.onEvent(event);
+    }
+  }
   recordHistoryEvent(type, payload) {
     const event = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -6078,6 +6786,47 @@ var CodexAspManager = class extends CodingAgentManager {
     this.historyEvents.push(event);
     return event;
   }
+  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/relay-tools.ts
@@ -6686,12 +7435,12 @@ var DuplicateDefaultChatError = class extends Error {
 };
 
 // src/services/chat/chat-service.ts
-var ENGINE_DIR2 = join14(homedir12(), ".replicas", "engine");
-var CHATS_FILE = join14(ENGINE_DIR2, "chats.json");
-var CLAUDE_HISTORY_DIR = join14(ENGINE_DIR2, "claude-histories");
-var RELAY_HISTORY_DIR = join14(ENGINE_DIR2, "relay-histories");
-var CHAT_SENDERS_DIR = join14(ENGINE_DIR2, "chat-senders");
-var CODEX_AUTH_PATH2 = join14(homedir12(), ".codex", "auth.json");
+var ENGINE_DIR2 = join15(homedir13(), ".replicas", "engine");
+var CHATS_FILE = join15(ENGINE_DIR2, "chats.json");
+var CLAUDE_HISTORY_DIR = join15(ENGINE_DIR2, "claude-histories");
+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;
   return typeof value.senderUserId === "string" && typeof value.senderEmail === "string" && typeof value.recordedAt === "string";
@@ -6714,10 +7463,10 @@ var ChatService = class {
   chats = /* @__PURE__ */ new Map();
   writeChain = Promise.resolve();
   async initialize() {
-    await mkdir10(ENGINE_DIR2, { recursive: true });
-    await mkdir10(CLAUDE_HISTORY_DIR, { recursive: true });
-    await mkdir10(RELAY_HISTORY_DIR, { recursive: true });
-    await mkdir10(CHAT_SENDERS_DIR, { recursive: true });
+    await mkdir11(ENGINE_DIR2, { recursive: true });
+    await mkdir11(CLAUDE_HISTORY_DIR, { recursive: true });
+    await mkdir11(RELAY_HISTORY_DIR, { recursive: true });
+    await mkdir11(CHAT_SENDERS_DIR, { recursive: true });
     const persisted = await this.loadChats();
     for (const chat of persisted) {
       const runtime = this.createRuntimeChat(chat);
@@ -6812,7 +7561,7 @@ var ChatService = class {
     };
   }
   senderFilePath(chatId) {
-    return join14(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
+    return join15(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
   }
   async appendSender(chatId, sender) {
     try {
@@ -6929,7 +7678,7 @@ var ChatService = class {
   async deleteHistoryFile(persisted) {
     if (persisted.provider === "claude" || persisted.provider === "relay") {
       const dir = persisted.provider === "claude" ? CLAUDE_HISTORY_DIR : RELAY_HISTORY_DIR;
-      await rm(join14(dir, `${persisted.id}.jsonl`), { force: true });
+      await rm(join15(dir, `${persisted.id}.jsonl`), { force: true });
     }
     await rm(this.senderFilePath(persisted.id), { force: true });
   }
@@ -6942,6 +7691,7 @@ var ChatService = class {
     return {
       thread_id: history.thread_id,
       events: history.events,
+      goal: history.goal ?? chat.provider.getGoal?.() ?? null,
       senders
     };
   }
@@ -6977,7 +7727,7 @@ var ChatService = class {
     if (persisted.provider === "claude") {
       provider = new ClaudeManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join14(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join15(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -6986,7 +7736,7 @@ var ChatService = class {
     } else if (persisted.provider === "relay") {
       provider = new RelayManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join14(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join15(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -7027,6 +7777,7 @@ var ChatService = class {
       processing: chat.provider.isProcessing(),
       awaitingInput: chat.provider.isAwaitingInput?.() ?? false,
       isCompacting: chat.provider.isCompacting?.() ?? false,
+      goal: chat.provider.getGoal?.() ?? null,
       parentChatId: chat.persisted.parentChatId
     };
   }
@@ -7069,7 +7820,7 @@ var ChatService = class {
       }
     }).catch(() => {
     });
-    if (event.type === "replicas-tool-input-request" || event.type === "replicas-tool-input-resolved" || event.type === "compaction-status") {
+    if (event.type === "replicas-tool-input-request" || event.type === "replicas-tool-input-resolved" || event.type === "compaction-status" || event.type === CHAT_GOAL_EVENT_TYPE) {
       this.publish({
         type: "chat.updated",
         payload: { chat: this.toSummary(chat) }
@@ -7122,7 +7873,7 @@ var ChatService = class {
     this.writeChain = this.writeChain.catch(() => {
     }).then(async () => {
       const payload = Array.from(this.chats.values()).map((chat) => chat.persisted);
-      await writeFile8(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
+      await writeFile9(CHATS_FILE, JSON.stringify(payload, null, 2), "utf-8");
     });
     await this.writeChain;
   }
@@ -7175,7 +7926,7 @@ var ChatService = class {
 // src/services/repo-file-service.ts
 import { execFile as execFile2 } from "child_process";
 import { readFile as readFile9, realpath, stat as stat3 } from "fs/promises";
-import { join as join15, resolve, extname } from "path";
+import { join as join16, resolve, extname } from "path";
 var CACHE_TTL_MS = 3e4;
 var SEARCH_TIMEOUT_MS = 15e3;
 var MAX_CONTENT_BYTES = 256 * 1024;
@@ -7335,7 +8086,7 @@ var RepoFileService = class {
     const repo = repos.find((r) => r.name === repoName);
     if (!repo) return null;
     try {
-      const fullPath = await realpath(resolve(join15(repo.path, filePath)));
+      const fullPath = await realpath(resolve(join16(repo.path, filePath)));
       const repoRoot = await realpath(repo.path);
       const repoPrefix = repoRoot.endsWith("/") ? repoRoot : repoRoot + "/";
       if (!fullPath.startsWith(repoPrefix) && fullPath !== repoRoot) return null;
@@ -7447,15 +8198,15 @@ var RepoFileService = class {
 import { Hono } from "hono";
 import { z as z2 } from "zod";
 import { readdir as readdir6, stat as stat4, readFile as readFile13 } from "fs/promises";
-import { join as join19, resolve as resolve2 } from "path";
+import { join as join20, resolve as resolve2 } from "path";
 
 // src/services/plan-service.ts
 import { readdir as readdir4, readFile as readFile10 } from "fs/promises";
-import { homedir as homedir13 } from "os";
-import { basename, join as join16 } from "path";
+import { homedir as homedir14 } from "os";
+import { basename, join as join17 } from "path";
 var PLAN_DIRECTORIES = [
-  join16(homedir13(), ".claude", "plans"),
-  join16(homedir13(), ".replicas", "plans")
+  join17(homedir14(), ".claude", "plans"),
+  join17(homedir14(), ".replicas", "plans")
 ];
 function isMarkdownFile(filename) {
   return filename.toLowerCase().endsWith(".md");
@@ -7489,7 +8240,7 @@ var PlanService = class {
       return null;
     }
     for (const directory of PLAN_DIRECTORIES) {
-      const filePath = join16(directory, safeFilename);
+      const filePath = join17(directory, safeFilename);
       try {
         const content = await readFile10(filePath, "utf-8");
         return { filename: safeFilename, content };
@@ -7505,14 +8256,14 @@ var planService = new PlanService();
 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";
+import { join as join19 } from "path";
 
 // src/services/warm-hook-logs-service.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir11, readFile as readFile11, writeFile as writeFile9, readdir as readdir5 } from "fs/promises";
-import { homedir as homedir14 } from "os";
-import { join as join17 } from "path";
-var LOGS_DIR2 = join17(homedir14(), ".replicas", "warm-hook-logs");
+import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile10, readdir as readdir5 } from "fs/promises";
+import { homedir as homedir15 } from "os";
+import { join as join18 } from "path";
+var LOGS_DIR2 = join18(homedir15(), ".replicas", "warm-hook-logs");
 function sanitizeFilename2(name) {
   const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
   const hash = createHash2("sha256").update(name).digest("hex").slice(0, 8);
@@ -7533,7 +8284,7 @@ function withPreview2(stored) {
 }
 var WarmHookLogsService = class {
   async ensureDir() {
-    await mkdir11(LOGS_DIR2, { recursive: true });
+    await mkdir12(LOGS_DIR2, { recursive: true });
   }
   async saveGlobalHookLog(entry) {
     await this.ensureDir();
@@ -7542,7 +8293,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile9(join17(LOGS_DIR2, globalFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile10(join18(LOGS_DIR2, globalFilename()), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -7552,7 +8303,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile9(join17(LOGS_DIR2, environmentFilename()), `${JSON.stringify(log, null, 2)}
+    await writeFile10(join18(LOGS_DIR2, environmentFilename()), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -7562,7 +8313,7 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile9(join17(LOGS_DIR2, repoFilename2(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile10(join18(LOGS_DIR2, repoFilename2(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -7581,7 +8332,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile11(join17(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile11(join18(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -7599,7 +8350,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? globalFilename() : hookType === "environment" ? environmentFilename() : repoFilename2(hookName);
     try {
-      const raw = await readFile11(join17(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile11(join18(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -7618,7 +8369,7 @@ var warmHookLogsService = new WarmHookLogsService();
 // src/services/warm-hooks-service.ts
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join18(repoPath, filename);
+    const configPath = join19(repoPath, filename);
     if (!existsSync8(configPath)) {
       continue;
     }
@@ -8422,7 +9173,7 @@ function createV1Routes(deps) {
       const logFiles = files.filter((f) => f.endsWith(".log"));
       const sessions = await Promise.all(
         logFiles.map(async (filename) => {
-          const filePath = join19(LOG_DIR, filename);
+          const filePath = join20(LOG_DIR, filename);
           const fileStat = await stat4(filePath);
           const sessionId = filename.replace(/\.log$/, "");
           return {