replicas-engine 0.1.217 → 0.1.219

package/dist/src/index.js

@@ -34,6 +34,7 @@ function codexReasoningEffortForThinkingLevel(thinkingLevel) {
 // ../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
@@ -1628,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";
 
@@ -1749,7 +1759,7 @@ function parseReplicasConfigString(content, filename) {
 }
 
 // ../shared/src/engine/environment.ts
-var DAYTONA_SNAPSHOT_ID = "26-05-2026-royal-york-v4";
+var DAYTONA_SNAPSHOT_ID = "27-05-2026-royal-york-v1";
 
 // ../shared/src/engine/types.ts
 var DEFAULT_CHAT_TITLES = {
@@ -6069,25 +6079,17 @@ async function restartCodexAspHost() {
   }
 }
 
-// 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";
-var TURN_STARTED_METHOD = "turn/started";
-var TURN_COMPLETED_METHOD = "turn/completed";
-var TURN_PLAN_UPDATED_METHOD = "turn/plan/updated";
-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 toReasoningEffort(thinkingLevel) {
   return codexReasoningEffortForThinkingLevel(thinkingLevel);
 }
@@ -6104,6 +6106,278 @@ function extractRateLimitsSnapshot(rateLimits) {
 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;
@@ -6111,6 +6385,7 @@ var CodexAspManager = class extends CodingAgentManager {
   historyEvents = [];
   emittedItemStages = /* @__PURE__ */ new Set();
   quotaStatus = new CodexQuotaStatusTracker();
+  currentGoal = null;
   constructor(options) {
     super(options);
     this.initializeManager(this.processMessageInternal.bind(this));
@@ -6137,48 +6412,72 @@ var CodexAspManager = class extends CodingAgentManager {
   }
   async getHistory() {
     if (!this.currentThreadId) {
-      return { thread_id: null, events: [] };
+      return { thread_id: null, events: [], goal: null };
     }
     try {
       const host = await getCodexAspHost();
-      const response = await host.client.request(
-        THREAD_READ_METHOD,
-        { threadId: this.currentThreadId, includeTurns: true }
-      );
-      const events = this.threadToHistoryEvents(response.thread);
+      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);
+        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))
+          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 userMessageRecorded = false;
-    const recordUserMessage = () => {
+    const recordUserMessage = (extraPayload = {}) => {
       if (userMessageRecorded) return;
       userMessageRecorded = true;
       this.recordHistoryEvent("event_msg", {
         type: "user_message",
-        message: request.message
+        message: request.message,
+        ...extraPayload
       });
     };
-    try {
+    const goalCommand = parseGoalCommand(request.message);
+    const dispatch = async () => {
+      if (goalCommand?.type === "clear") {
+        await this.executeGoalClearCommand(request, recordUserMessage);
+        return;
+      }
+      if (goalCommand?.type === "set") {
+        await this.executeAspTurn(request, recordUserMessage, {
+          runTurn: (host, threadId) => this.runGoalTurn(host, threadId, request, goalCommand.objective),
+          userMessagePayload: { command: "goal" }
+        });
+        return;
+      }
       await this.executeAspTurn(request, recordUserMessage);
+    };
+    try {
+      await dispatch();
     } catch (error) {
       if (isCodexAuthError(error)) {
         const refreshed = await codexTokenManager.fetchFreshCredentials(error instanceof Error ? error.message : String(error));
         if (refreshed) {
           await restartCodexAspHost();
           this.threadAttached = false;
-          await this.executeAspTurn(request, recordUserMessage);
+          await dispatch();
           return;
         }
       }
@@ -6188,22 +6487,34 @@ var CodexAspManager = class extends CodingAgentManager {
       await this.onTurnComplete();
     }
   }
-  async executeAspTurn(request, recordUserMessage) {
+  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();
+        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();
+    recordUserMessage(options.userMessagePayload);
+    const runTurn = options.runTurn ?? ((aspHost, aspThreadId, aspInstructions) => this.runTurn(aspHost, aspThreadId, request, aspInstructions));
     let completedTurn;
     try {
-      completedTurn = await this.runTurn(host, threadId, request, developerInstructions);
+      completedTurn = await runTurn(host, threadId, developerInstructions);
     } catch (error) {
       await this.refreshQuotaSnapshot(host);
       if (this.quotaStatus.blocked) {
@@ -6216,7 +6527,7 @@ var CodexAspManager = class extends CodingAgentManager {
       if (this.quotaStatus.blocked) {
         return;
       }
-      throw new Error(this.formatTurnFailure(completedTurn));
+      throw new Error(formatTurnFailure(completedTurn));
     }
     if (completedTurn.status === "completed") {
       this.emitTurnCompletedItems(completedTurn);
@@ -6227,7 +6538,7 @@ var CodexAspManager = class extends CodingAgentManager {
       if (!this.threadAttached) {
         const response = await host.client.request(
           THREAD_RESUME_METHOD,
-          await this.buildThreadResumeParams(this.currentThreadId, request, developerInstructions)
+          await buildThreadResumeParams(this.workingDirectory, this.currentThreadId, request, developerInstructions)
         );
         this.currentThreadId = response.thread.id;
         this.threadAttached = true;
@@ -6238,82 +6549,34 @@ var CodexAspManager = class extends CodingAgentManager {
     }
     const threadStartResponse = await host.client.request(
       THREAD_START_METHOD,
-      await this.buildThreadStartParams(request, developerInstructions)
+      await buildThreadStartParams(this.workingDirectory, request, developerInstructions)
     );
     this.currentThreadId = threadStartResponse.thread.id;
     this.threadAttached = true;
     await this.onSaveSessionId(this.currentThreadId);
     return this.currentThreadId;
   }
-  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 buildThreadResumeParams(threadId, request, developerInstructions) {
-    const additionalDirectories = await getAgentAdditionalDirectories();
-    return {
-      threadId,
-      model: request.model ?? DEFAULT_MODEL2,
-      cwd: this.workingDirectory,
-      runtimeWorkspaceRoots: additionalDirectories,
-      sandbox: "danger-full-access",
-      developerInstructions: developerInstructions ?? null,
-      config: { web_search: "live" },
-      excludeTurns: false,
-      persistExtendedHistory: false
-    };
-  }
-  async buildTurnStartParams(threadId, request, developerInstructions) {
-    const effort = toReasoningEffort(request.thinkingLevel);
-    const model = request.model ?? DEFAULT_MODEL2;
-    const { input, tempImagePaths } = await this.buildTurnInput(request);
-    return {
-      params: {
-        threadId,
-        input,
-        model,
-        ...effort ? { effort } : {},
-        ...developerInstructions ? {
-          collaborationMode: {
-            mode: "default",
-            settings: {
-              model,
-              reasoning_effort: effort ?? null,
-              developer_instructions: developerInstructions
-            }
-          }
-        } : {}
-      },
-      tempImagePaths
-    };
+  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 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 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 runTurn(host, threadId, request, developerInstructions) {
+  async observeTurn(host, threadId, request, startTurn) {
     let resolveCompleted;
     const completed = new Promise((resolve3) => {
       resolveCompleted = resolve3;
@@ -6333,46 +6596,46 @@ var CodexAspManager = class extends CodingAgentManager {
     let tempImagePaths = [];
     const linearForwarder = new LinearEventForwarder(linearSessionId);
     const matchesTurn = (notificationThreadId, notificationTurnId) => notificationThreadId === threadId && (!observedTurnId || notificationTurnId === null || notificationTurnId === observedTurnId);
-    const onNotification = (notification) => {
-      if (notification.method === ACCOUNT_RATE_LIMITS_UPDATED_METHOD) {
+    const handlers = {
+      [ACCOUNT_RATE_LIMITS_UPDATED_METHOD]: (notification) => {
         this.handleRateLimits(notification.params.rateLimits);
-        return;
-      }
-      if (notification.method === THREAD_TOKEN_USAGE_UPDATED_METHOD) {
-        if (notification.params.threadId === threadId) {
-          this.emitCodexTokenUsage(notification.params.tokenUsage, model);
-        }
-        return;
-      }
-      if (notification.method === THREAD_COMPACTED_METHOD) {
-        if (matchesTurn(notification.params.threadId, notification.params.turnId)) {
-          this.setCompacting(false);
-        }
-        return;
-      }
-      if (notification.method === TURN_STARTED_METHOD) {
+      },
+      [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 ?? ""));
-        return;
-      }
-      if (notification.method === TURN_PLAN_UPDATED_METHOD) {
+      },
+      [TURN_PLAN_UPDATED_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
         this.emitPlanUpdate(notification.params.plan);
         linearForwarder.sendPlan(extractPlanFromCodexAspNotification(notification));
-        return;
-      }
-      if (notification.method === ITEM_STARTED_METHOD) {
+      },
+      [ITEM_STARTED_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
         if (notification.params.item.type === "contextCompaction") {
           this.setCompacting(true);
         }
         this.emitThreadItemLifecycle(notification.params.item, "started");
         linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
-        return;
-      }
-      if (notification.method === ITEM_COMPLETED_METHOD) {
+      },
+      [ITEM_COMPLETED_METHOD]: (notification) => {
         if (!matchesTurn(notification.params.threadId, notification.params.turnId)) return;
         completedItems.push(notification.params.item);
         if (notification.params.item.type === "contextCompaction") {
@@ -6380,19 +6643,14 @@ var CodexAspManager = class extends CodingAgentManager {
         }
         this.emitThreadItemLifecycle(notification.params.item, "completed");
         linearForwarder.sendEvent(convertCodexAspNotification(notification, linearSessionId ?? ""));
-        return;
-      }
-      if (notification.method === AGENT_MESSAGE_DELTA_METHOD) {
-        if (matchesTurn(notification.params.threadId, notification.params.turnId)) {
-          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;
-        }
+      },
+      [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] : [];
@@ -6417,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;
@@ -6434,14 +6695,12 @@ var CodexAspManager = class extends CodingAgentManager {
     host.client.on("serverRequest", onServerRequest);
     host.client.on("dispose", onDispose);
     try {
-      const { params, tempImagePaths: turnTempImagePaths } = await this.buildTurnStartParams(threadId, request, developerInstructions);
-      tempImagePaths = turnTempImagePaths;
-      const turnStartResponse = await host.client.request(
-        TURN_START_METHOD,
-        params
-      );
-      observedTurnId = turnStartResponse.turn.id;
-      this.activeTurnId = turnStartResponse.turn.id;
+      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;
@@ -6462,10 +6721,10 @@ var CodexAspManager = class extends CodingAgentManager {
     }
     if (lifecycle === "completed" && !this.emittedItemStages.has(`started:${item.id}`)) {
       this.emittedItemStages.add(`started:${item.id}`);
-      this.recordAndEmitDrafts(this.itemToAgentEventDrafts(item, "started"));
+      this.recordAndEmitDrafts(itemToAgentEventDrafts(item, "started"));
     }
     this.emittedItemStages.add(stageKey);
-    this.recordAndEmitDrafts(this.itemToAgentEventDrafts(item, lifecycle));
+    this.recordAndEmitDrafts(itemToAgentEventDrafts(item, lifecycle));
   }
   emitTurnCompletedItems(turn) {
     for (const item of turn.items) {
@@ -6484,141 +6743,34 @@ var CodexAspManager = class extends CodingAgentManager {
       }
     }]);
   }
-  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: this.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: this.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 [];
-  }
-  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 this.itemToAgentEventDrafts(item, "started")) {
-          events.push({ timestamp: startedAt, ...draft });
-        }
-        for (const draft of this.itemToAgentEventDrafts(item, "completed")) {
-          events.push({ timestamp: completedAt, ...draft });
-        }
-      }
-    }
-    return events;
-  }
   seedHistoryFromThread(thread) {
-    const events = this.threadToHistoryEvents(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);
+    }
+  }
+  recordGoalChange(goal, force = false) {
+    const nextGoal = goal ? aspGoalToChatGoal(goal) : null;
+    if (!force && JSON.stringify(this.currentGoal) === JSON.stringify(nextGoal)) {
+      return;
+    }
+    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);
@@ -6675,46 +6827,6 @@ var CodexAspManager = class extends CodingAgentManager {
     const event = this.emitContextUsage(payload);
     this.historyEvents.push(event);
   }
-  formatCommandOutput(item) {
-    const exitCode = item.exitCode ?? (item.status === "completed" ? 0 : 1);
-    const output = item.aggregatedOutput ?? "";
-    return output ? `Exit code: ${exitCode}
-${output}` : `Exit code: ${exitCode}`;
-  }
-  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");
-  }
-  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(" ");
-  }
 };
 
 // src/managers/relay-tools.ts
@@ -7579,6 +7691,7 @@ var ChatService = class {
     return {
       thread_id: history.thread_id,
       events: history.events,
+      goal: history.goal ?? chat.provider.getGoal?.() ?? null,
       senders
     };
   }
@@ -7664,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
     };
   }
@@ -7706,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) }
@@ -8146,10 +8260,11 @@ import { join as join19 } from "path";
 
 // src/services/warm-hook-logs-service.ts
 import { createHash as createHash2 } from "crypto";
-import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile10, readdir as readdir5 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile11, writeFile as writeFile10, readdir as readdir5, appendFile as appendFile6, unlink as unlink3 } from "fs/promises";
 import { homedir as homedir15 } from "os";
 import { join as join18 } from "path";
 var LOGS_DIR2 = join18(homedir15(), ".replicas", "warm-hook-logs");
+var CURRENT_RUN_LOG = join18(LOGS_DIR2, "current-run.log");
 function sanitizeFilename2(name) {
   const safe = name.replace(/[^a-zA-Z0-9._-]/g, "_");
   const hash = createHash2("sha256").update(name).digest("hex").slice(0, 8);
@@ -8233,6 +8348,26 @@ var WarmHookLogsService = class {
     });
     return logs;
   }
+  async resetCurrentRunLog() {
+    await this.ensureDir();
+    try {
+      await unlink3(CURRENT_RUN_LOG);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+  async appendCurrentRunLog(chunk) {
+    if (!chunk) return;
+    await appendFile6(CURRENT_RUN_LOG, chunk, "utf-8");
+  }
+  async getCurrentRunLog() {
+    try {
+      return await readFile11(CURRENT_RUN_LOG, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+  }
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? globalFilename() : hookType === "environment" ? environmentFilename() : repoFilename2(hookName);
     try {
@@ -8359,6 +8494,16 @@ async function executeHookScriptStreaming(params) {
   });
 }
 async function runWarmHooksStreaming(params) {
+  await warmHookLogsService.resetCurrentRunLog();
+  const originalOnEvent = params.onEvent;
+  const onEvent = (event) => {
+    if (event.type === "output" && event.data) {
+      void warmHookLogsService.appendCurrentRunLog(event.data).catch(() => {
+      });
+    }
+    originalOnEvent(event);
+  };
+  params = { ...params, onEvent };
   const outputBlocks = [];
   const globalHook = (params.globalWarmHook ?? params.organizationWarmHook)?.trim();
   const environmentHook = params.environmentWarmHook?.trim();
@@ -8952,6 +9097,17 @@ function createV1Routes(deps) {
       );
     }
   });
+  app2.get("/warm-hooks/current-run/log", async (c) => {
+    try {
+      const output = await warmHookLogsService.getCurrentRunLog();
+      return c.json({ output: output ?? "" });
+    } catch (error) {
+      return c.json(
+        jsonError("Failed to read current warm hook run log", error instanceof Error ? error.message : "Unknown error"),
+        500
+      );
+    }
+  });
   app2.get("/warm-hooks/logs/:hookType/:hookName/full", async (c) => {
     try {
       const hookType = c.req.param("hookType");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "replicas-engine",
-  "version": "0.1.217",
+  "version": "0.1.219",
   "description": "Lightweight API server for Replicas workspaces",
   "type": "module",
   "main": "dist/src/index.js",