remote-codex 0.11.25 → 0.11.27

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

@@ -10862,6 +10862,15 @@ var HIDDEN_ASK_USER_QUESTION_CONTINUATION_PREFIX = "The user answered the clarif
 var SUPPRESSED_ASSISTANT_TEXTS = /* @__PURE__ */ new Set([
   "No response requested."
 ]);
+var CLAUDE_LIMIT_ERROR_PATTERNS = [
+  /\byou(?:'|’)ve hit your session limit\b/i,
+  /\byou have hit your session limit\b/i,
+  /\b(?:hit|reached|exceeded) (?:the )?(?:session|usage|rate) limit\b/i,
+  /\b(?:session|usage|rate) limit (?:hit|reached|exceeded)\b/i,
+  /\bquota exceeded\b/i,
+  /\bcredit balance (?:is )?(?:too low|insufficient|exhausted)\b/i,
+  /\binsufficient credits?\b/i
+];
 function normalizedToolName(toolName) {
   return toolName.replace(/[\s_-]+/g, "").toLowerCase();
 }
@@ -10903,6 +10912,23 @@ function compactJson(value) {
     return String(value);
   }
 }
+function joinReasoningText(left, right) {
+  if (!left) {
+    return right;
+  }
+  if (!right) {
+    return left;
+  }
+  if (right.startsWith(left)) {
+    return right;
+  }
+  if (left.endsWith(right)) {
+    return left;
+  }
+  return `${left}
+
+${right}`;
+}
 function readableToolName(toolName) {
   if (CLAUDE_TOOL_LABELS[toolName]) {
     return CLAUDE_TOOL_LABELS[toolName];
@@ -11026,6 +11052,26 @@ function isHiddenContinuationMessage(message) {
 function shouldSuppressAssistantText(text2) {
   return SUPPRESSED_ASSISTANT_TEXTS.has(text2.trim());
 }
+function claudeLimitErrorMessage(text2) {
+  const normalized = text2?.trim();
+  if (!normalized) {
+    return null;
+  }
+  return CLAUDE_LIMIT_ERROR_PATTERNS.some((pattern) => pattern.test(normalized)) ? normalized : null;
+}
+function limitErrorFromHistoryItems(items) {
+  for (let index = items.length - 1; index >= 0; index -= 1) {
+    const item = items[index];
+    if (item?.kind !== "agentMessage") {
+      continue;
+    }
+    const error = claudeLimitErrorMessage(item.text);
+    if (error) {
+      return error;
+    }
+  }
+  return null;
+}
 function userMessageToHistoryItem(id, message) {
   return {
     id,
@@ -11165,6 +11211,28 @@ function toolResultBlocks(message) {
     };
   }).filter((block) => Boolean(block));
 }
+function xmlTagText(input, tagName) {
+  const match = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, "i").exec(input);
+  return match?.[1]?.trim() || null;
+}
+function decodeBasicXmlEntities(input) {
+  return input.replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+}
+function taskNotificationToolResult(message) {
+  const text2 = messageContentText(message).trim();
+  if (!text2.startsWith("<task-notification>") || !text2.includes("</task-notification>")) {
+    return null;
+  }
+  const toolUseId = xmlTagText(text2, "tool-use-id");
+  if (!toolUseId) {
+    return null;
+  }
+  const result = xmlTagText(text2, "result") ?? xmlTagText(text2, "summary") ?? text2;
+  return {
+    toolUseId,
+    result: decodeBasicXmlEntities(result)
+  };
+}
 function suppressedClaudeToolUseIds(message) {
   const ids = /* @__PURE__ */ new Set();
   for (const block of contentBlocks(message)) {
@@ -11207,11 +11275,16 @@ function assistantMessageToHistoryItems(input) {
     if (type === "thinking") {
       const thinking = thinkingTextFromBlock(block);
       if (thinking) {
-        items.push({
-          id: `${input.messageId}:content:${index}`,
-          kind: "reasoning",
-          text: thinking
-        });
+        const previous = items.at(-1);
+        if (previous?.kind === "reasoning") {
+          previous.text = joinReasoningText(previous.text, thinking);
+        } else {
+          items.push({
+            id: `${input.messageId}:content:${index}`,
+            kind: "reasoning",
+            text: thinking
+          });
+        }
       }
       continue;
     }
@@ -11403,12 +11476,15 @@ function resultForToolUse(input) {
   };
 }
 function buildAgentTurn(input) {
+  const startedAt = input.startedAt ?? null;
   const turn = {
     providerTurnId: input.providerTurnId,
-    startedAt: input.startedAt ?? null,
+    startedAt,
     status: input.status,
     error: input.error ? { message: input.error } : null,
-    items: input.items
+    items: input.items.map(
+      (item) => item.createdAt || !startedAt ? item : { ...item, createdAt: startedAt }
+    )
   };
   if (input.rawTurn !== void 0) {
     turn.rawTurn = input.rawTurn;
@@ -11867,6 +11943,13 @@ function queryResultError(message) {
   }
   return message.errors?.join("\n") || message.stop_reason || "Claude turn failed.";
 }
+function statusForHistoricalItems(items) {
+  const limitError = limitErrorFromHistoryItems(items);
+  return {
+    status: limitError ? "failed" : "completed",
+    error: limitError
+  };
+}
 function assistantMessagePayload(message) {
   return message.type === "assistant" ? message.message : null;
 }
@@ -11955,6 +12038,9 @@ function streamMessageId(event) {
   const message = event.message;
   return messageIdFromPayload(message);
 }
+function sessionMessageTimestamp(message) {
+  return typeof message.uuid === "string" ? isoFromUuidV7(message.uuid) : null;
+}
 function addOrUpdateItem(state, item) {
   if (!state.items.has(item.id)) {
     state.itemOrder.push(item.id);
@@ -11964,6 +12050,53 @@ function addOrUpdateItem(state, item) {
 function orderedItems(state) {
   return state.itemOrder.map((id) => state.items.get(id)).filter((item) => Boolean(item));
 }
+function withHistoryItemCreatedAt(item, createdAt) {
+  if (item.createdAt || !createdAt) {
+    return item;
+  }
+  return { ...item, createdAt };
+}
+function latestReasoningItem(state) {
+  const lastItemId = state.itemOrder.at(-1);
+  const lastItem = lastItemId ? state.items.get(lastItemId) : null;
+  return lastItem?.kind === "reasoning" ? lastItem : null;
+}
+function joinReasoningText2(left, right) {
+  if (!left) {
+    return right;
+  }
+  if (!right) {
+    return left;
+  }
+  if (right.startsWith(left)) {
+    return right;
+  }
+  if (left.endsWith(right)) {
+    return left;
+  }
+  return `${left}
+
+${right}`;
+}
+function isRunningHistoryItemStatus(status) {
+  const normalized = status?.trim().toLowerCase();
+  return normalized === "running" || normalized === "pending" || normalized === "in_progress" || normalized === "in progress";
+}
+function finalizeTurnItems(state, status, completedAt) {
+  return orderedItems(state).map((item) => {
+    if (item.kind === "userMessage") {
+      return item;
+    }
+    if (status === "completed" && isRunningHistoryItemStatus(item.status)) {
+      return {
+        ...item,
+        status: "completed",
+        createdAt: item.createdAt ?? completedAt
+      };
+    }
+    return withHistoryItemCreatedAt(item, completedAt);
+  });
+}
 function stringFromRecord(value, key) {
   const raw = value[key];
   return typeof raw === "string" && raw.trim() ? raw : null;
@@ -12286,7 +12419,13 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     const sessions = await this.withClaudeConfigEnv(() => this.listSessionsFn({}));
     return sessions.map((session) => {
       this.knownSessionIds.add(session.sessionId);
-      return sessionSummaryFromInfo(session);
+      const summary = sessionSummaryFromInfo(session);
+      const activeTurn = this.activeTurnForSession(summary.providerSessionId);
+      return activeTurn ? {
+        ...summary,
+        status: "running",
+        updatedAt: summary.updatedAt ?? activeTurn.startedAt
+      } : summary;
     });
   }
   async listLoadedSessions() {
@@ -12453,9 +12592,12 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         tools: { type: "preset", preset: "claude_code" }
       })
     });
-    const userItem = userMessageToHistoryItem(`${providerTurnId}:user`, {
-      content: input.prompt
-    });
+    const userItem = withHistoryItemCreatedAt(
+      userMessageToHistoryItem(`${providerTurnId}:user`, {
+        content: input.prompt
+      }),
+      startedAt
+    );
     const initialItems = input.hidden ? [] : [userItem];
     const state = {
       providerSessionId: input.providerSessionId,
@@ -12538,6 +12680,14 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       this.liveUserPrompts.delete(state.providerSessionId);
     }
   }
+  activeTurnForSession(providerSessionId) {
+    for (const state of this.activeTurns.values()) {
+      if (state.providerSessionId === providerSessionId && !state.completed) {
+        return state;
+      }
+    }
+    return null;
+  }
   reconcileActiveTranscriptTurn(providerSessionId, turns, activeTurn) {
     if (!activeTurn || turns.length === 0) {
       return turns;
@@ -12590,37 +12740,25 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
   }
   async consumeQuery(state) {
     const rawMessages = [];
+    let terminalStatus = null;
+    let terminalError = null;
     try {
       for await (const message of state.query) {
         rawMessages.push(message);
-        if (state.completed) {
-          continue;
-        }
         this.consumeMessage(state, message);
         const status = queryResultStatus(message);
         if (status) {
-          state.completed = true;
-          this.deleteActiveTurn(state);
-          this.emitUsage(state);
-          this.emitRuntimeEvent({
-            type: "turn.completed",
-            provider: "claude",
-            providerSessionId: state.providerSessionId,
-            turn: buildAgentTurn({
-              providerTurnId: state.providerTurnId,
-              startedAt: state.startedAt,
-              status: state.interrupted ? "interrupted" : status,
-              error: queryResultError(message),
-              items: orderedItems(state),
-              rawTurn: rawMessages
-            })
-          });
+          terminalStatus = status;
+          terminalError = queryResultError(message);
         }
       }
       if (!state.completed) {
         state.completed = true;
         this.deleteActiveTurn(state);
         this.emitUsage(state);
+        const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        const limitError = limitErrorFromHistoryItems(orderedItems(state));
+        const status = state.interrupted ? "interrupted" : limitError ? "failed" : terminalStatus ?? "completed";
         this.emitRuntimeEvent({
           type: "turn.completed",
           provider: "claude",
@@ -12628,8 +12766,9 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
           turn: buildAgentTurn({
             providerTurnId: state.providerTurnId,
             startedAt: state.startedAt,
-            status: state.interrupted ? "interrupted" : "completed",
-            items: orderedItems(state),
+            status,
+            error: limitError ?? terminalError,
+            items: finalizeTurnItems(state, status, completedAt),
             rawTurn: rawMessages
           })
         });
@@ -12650,6 +12789,7 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
   }
   consumeMessage(state, message) {
     this.captureUsage(state, message);
+    const messageCreatedAt = (/* @__PURE__ */ new Date()).toISOString();
     if (message.type === "system" && message.subtype === "init") {
       this.updateToolboxItemsFromSystemInit(message);
       if (message.session_id) {
@@ -12669,8 +12809,9 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         event: message.event
       });
       if (toolItem) {
-        addOrUpdateItem(state, toolItem);
-        this.emitItem(state, toolItem, "item.started");
+        const nextItem = withHistoryItemCreatedAt(toolItem, messageCreatedAt);
+        addOrUpdateItem(state, nextItem);
+        this.emitItem(state, nextItem, "item.started");
         return;
       }
       const reasoningItem = partialReasoningDelta({
@@ -12679,14 +12820,15 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       });
       if (reasoningItem) {
         const existing = state.items.get(reasoningItem.id);
-        const nextItem = existing?.kind === "reasoning" ? {
-          ...existing,
-          text: `${existing.text}${reasoningItem.text}`,
-          status: reasoningItem.status ?? existing.status ?? null
-        } : reasoningItem;
+        const previousReasoning = existing?.kind === "reasoning" ? existing : latestReasoningItem(state);
+        const nextItem = previousReasoning ? {
+          ...previousReasoning,
+          text: previousReasoning.id === reasoningItem.id ? `${previousReasoning.text}${reasoningItem.text}` : joinReasoningText2(previousReasoning.text, reasoningItem.text),
+          status: reasoningItem.status ?? previousReasoning.status ?? null
+        } : withHistoryItemCreatedAt(reasoningItem, messageCreatedAt);
         addOrUpdateItem(state, nextItem);
-        this.emitItem(state, nextItem, existing ? "item.completed" : "item.started", {
-          force: Boolean(existing)
+        this.emitItem(state, nextItem, previousReasoning ? "item.completed" : "item.started", {
+          force: Boolean(previousReasoning)
         });
         return;
       }
@@ -12701,6 +12843,7 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
           text: `${existing.text}${delta.delta}`
         }) : markTransientAgentHistoryItem({
           id: delta.itemId,
+          createdAt: messageCreatedAt,
           kind: "agentMessage",
           text: delta.delta
         });
@@ -12717,6 +12860,18 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       return;
     }
     if (message.type === "user") {
+      const taskNotification = taskNotificationToolResult(message.message);
+      if (taskNotification && !state.suppressedToolUseIds.has(taskNotification.toolUseId)) {
+        const item = resultForToolUse({
+          toolUseId: taskNotification.toolUseId,
+          result: message.tool_use_result ?? taskNotification.result,
+          previous: state.items.get(taskNotification.toolUseId) ?? null
+        });
+        const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+        addOrUpdateItem(state, nextItem);
+        this.emitItem(state, nextItem, "item.completed");
+        return;
+      }
       const rawToolResults = toolResultBlocks(message.message);
       const toolResults = rawToolResults.filter(
         (toolResult) => !state.suppressedToolUseIds.has(toolResult.toolUseId)
@@ -12728,8 +12883,9 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
             result: message.tool_use_result ?? toolResult.result,
             previous: state.items.get(toolResult.toolUseId) ?? null
           });
-          addOrUpdateItem(state, item);
-          this.emitItem(state, item, "item.completed");
+          const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+          addOrUpdateItem(state, nextItem);
+          this.emitItem(state, nextItem, "item.completed");
         }
         return;
       }
@@ -12760,12 +12916,13 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         messageId: assistantMessageId,
         message: payload
       })) {
-        const existing = state.items.get(item.id);
-        addOrUpdateItem(state, item);
-        if (item.kind !== "agentMessage" && !existing) {
-          this.emitItem(state, item, "item.started");
-        } else if (item.kind !== "agentMessage" && existing) {
-          this.emitItem(state, item, "item.started", { force: true });
+        const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+        const existing = state.items.get(nextItem.id);
+        addOrUpdateItem(state, nextItem);
+        if (nextItem.kind !== "agentMessage" && !existing) {
+          this.emitItem(state, nextItem, "item.started");
+        } else if (nextItem.kind !== "agentMessage" && existing) {
+          this.emitItem(state, nextItem, "item.started", { force: true });
         }
       }
       return;
@@ -12779,8 +12936,9 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         result: message.tool_use_result ?? message.message,
         previous: state.items.get(message.parent_tool_use_id) ?? null
       });
-      addOrUpdateItem(state, item);
-      this.emitItem(state, item, "item.completed");
+      const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+      addOrUpdateItem(state, nextItem);
+      this.emitItem(state, nextItem, "item.completed");
       return;
     }
     if (message.type === "tool_progress") {
@@ -12799,8 +12957,9 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
           status: "running"
         });
         if (item) {
-          addOrUpdateItem(state, item);
-          this.emitItem(state, item, "item.started");
+          const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+          addOrUpdateItem(state, nextItem);
+          this.emitItem(state, nextItem, "item.started");
         } else {
           state.suppressedToolUseIds.add(toolUseId);
         }
@@ -12819,13 +12978,15 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         detailText: [previous.detailText ?? previous.text, "", message.message].join("\n")
       } : {
         id: toolUseId,
+        createdAt: messageCreatedAt,
         kind: "toolCall",
         text: `${message.tool_name} denied`,
         detailText: typeof message.message === "string" ? message.message : null,
         status: "denied"
       };
-      addOrUpdateItem(state, item);
-      this.emitItem(state, item, "item.completed");
+      const nextItem = withHistoryItemCreatedAt(item, messageCreatedAt);
+      addOrUpdateItem(state, nextItem);
+      this.emitItem(state, nextItem, "item.completed");
     }
   }
   captureUsage(state, message) {
@@ -12996,6 +13157,18 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
           itemsById: /* @__PURE__ */ new Map()
         };
       }
+      const previous = current.items.at(-1);
+      if (item.kind === "reasoning" && previous?.kind === "reasoning") {
+        const merged = {
+          ...previous,
+          text: joinReasoningText2(previous.text, item.text),
+          status: item.status ?? previous.status ?? null
+        };
+        current.items[current.items.length - 1] = merged;
+        current.itemsById.set(previous.id, merged);
+        current.itemsById.set(item.id, merged);
+        return;
+      }
       const existingIndex = current.items.findIndex((entry) => entry.id === item.id);
       if (existingIndex >= 0) {
         current.items[existingIndex] = item;
@@ -13006,6 +13179,24 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     };
     for (const message of messages) {
       if (message.type === "user") {
+        const taskNotification = taskNotificationToolResult(message.message);
+        if (taskNotification) {
+          if (suppressedToolUseIds.has(taskNotification.toolUseId)) {
+            continue;
+          }
+          const previous = current?.itemsById.get(taskNotification.toolUseId) ?? null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              resultForToolUse({
+                toolUseId: taskNotification.toolUseId,
+                result: message.tool_use_result ?? taskNotification.result,
+                previous
+              }),
+              sessionMessageTimestamp(message) ?? current?.startedAt
+            )
+          );
+          continue;
+        }
         const rawToolResults = toolResultBlocks(message.message);
         const toolResults = rawToolResults.filter(
           (toolResult) => !suppressedToolUseIds.has(toolResult.toolUseId)
@@ -13013,11 +13204,16 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         if (toolResults.length > 0) {
           for (const toolResult of toolResults) {
             const previous = current?.itemsById.get(toolResult.toolUseId) ?? null;
-            upsertCurrentItem(resultForToolUse({
-              toolUseId: toolResult.toolUseId,
-              result: toolResult.result,
-              previous
-            }));
+            upsertCurrentItem(
+              withHistoryItemCreatedAt(
+                resultForToolUse({
+                  toolUseId: toolResult.toolUseId,
+                  result: toolResult.result,
+                  previous
+                }),
+                sessionMessageTimestamp(message) ?? current?.startedAt
+              )
+            );
           }
           continue;
         }
@@ -13036,24 +13232,28 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         }
         skippingHiddenInit = false;
         if (current && current.items.length > 0) {
+          const outcome = statusForHistoricalItems(current.items);
           turns.push(buildAgentTurn({
             providerTurnId: current.providerTurnId,
             startedAt: current.startedAt,
-            status: "completed",
+            status: outcome.status,
+            error: outcome.error,
             items: current.items
           }));
         }
         const messageUuid2 = message.uuid ?? randomUUID2();
+        const userStartedAt = isoFromUuidV7(messageUuid2);
         const userItem = await this.userMessageToHistoryItem(
           messageUuid2,
           message.message,
           context
         );
+        const stampedUserItem = withHistoryItemCreatedAt(userItem, userStartedAt);
         current = {
           providerTurnId: `claude-turn-${messageUuid2}`,
-          startedAt: isoFromUuidV7(messageUuid2),
-          items: [userItem],
-          itemsById: /* @__PURE__ */ new Map([[messageUuid2, userItem]])
+          startedAt: userStartedAt,
+          items: [stampedUserItem],
+          itemsById: /* @__PURE__ */ new Map([[messageUuid2, stampedUserItem]])
         };
         continue;
       }
@@ -13061,6 +13261,7 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         continue;
       }
       if (message.type === "assistant") {
+        const assistantCreatedAt = sessionMessageTimestamp(message) ?? current?.startedAt;
         for (const toolUseId of suppressedClaudeToolUseIds(message.message)) {
           suppressedToolUseIds.add(toolUseId);
           current?.itemsById.delete(toolUseId);
@@ -13069,7 +13270,7 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
           messageId: message.uuid ?? randomUUID2(),
           message: message.message
         })) {
-          upsertCurrentItem(item);
+          upsertCurrentItem(withHistoryItemCreatedAt(item, assistantCreatedAt));
         }
         continue;
       }
@@ -13078,18 +13279,25 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
           continue;
         }
         const previous = current?.itemsById.get(message.parent_tool_use_id) ?? null;
-        upsertCurrentItem(resultForToolUse({
-          toolUseId: message.parent_tool_use_id,
-          result: isRecord8(message.message) && "content" in message.message ? message.message.content : message.message,
-          previous
-        }));
+        upsertCurrentItem(
+          withHistoryItemCreatedAt(
+            resultForToolUse({
+              toolUseId: message.parent_tool_use_id,
+              result: isRecord8(message.message) && "content" in message.message ? message.message.content : message.message,
+              previous
+            }),
+            sessionMessageTimestamp(message) ?? current?.startedAt
+          )
+        );
       }
     }
     if (current && current.items.length > 0) {
+      const outcome = statusForHistoricalItems(current.items);
       turns.push(buildAgentTurn({
         providerTurnId: current.providerTurnId,
         startedAt: current.startedAt,
-        status: "completed",
+        status: outcome.status,
+        error: outcome.error,
         items: current.items
       }));
     }
@@ -14954,7 +15162,7 @@ var E2EFakeRuntime = class extends EventEmitter7 {
       permissionRequests: false,
       sandboxMode: false,
       performanceMode: false,
-      goals: false
+      goals: true
     },
     management: {
       models: true,
@@ -14970,6 +15178,12 @@ var E2EFakeRuntime = class extends EventEmitter7 {
   managementSchema = {
     hostConfigFiles: [],
     toolboxItems: [
+      {
+        action: "goal",
+        command: "/goal",
+        label: "Goal",
+        description: "Manage the current goal."
+      },
       {
         action: "fork",
         command: "/fork",
@@ -14996,6 +15210,7 @@ var E2EFakeRuntime = class extends EventEmitter7 {
   };
   sessions = /* @__PURE__ */ new Map();
   providerRequests = /* @__PURE__ */ new Map();
+  goals = /* @__PURE__ */ new Map();
   activeTurnId = null;
   startedAt = null;
   getStatus() {
@@ -15107,6 +15322,42 @@ var E2EFakeRuntime = class extends EventEmitter7 {
       rawSession: session
     };
   }
+  async getGoal(providerSessionId) {
+    return this.goals.get(providerSessionId) ?? null;
+  }
+  async setGoal(input) {
+    const existing = this.goals.get(input.providerSessionId);
+    const now = Date.now();
+    const goal = {
+      providerSessionId: input.providerSessionId,
+      objective: input.objective ?? existing?.objective ?? "E2E shared goal",
+      status: input.status ?? existing?.status ?? "active",
+      tokenBudget: input.tokenBudget !== void 0 ? input.tokenBudget : existing?.tokenBudget ?? null,
+      tokensUsed: existing?.tokensUsed ?? 0,
+      timeUsedSeconds: existing?.timeUsedSeconds ?? 0,
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+      rawGoal: null
+    };
+    this.goals.set(input.providerSessionId, goal);
+    this.emitRuntimeEvent({
+      type: "goal.updated",
+      provider,
+      providerSessionId: input.providerSessionId,
+      providerTurnId: null,
+      goal
+    });
+    return goal;
+  }
+  async clearGoal(providerSessionId) {
+    const existed = this.goals.delete(providerSessionId);
+    this.emitRuntimeEvent({
+      type: "goal.cleared",
+      provider,
+      providerSessionId
+    });
+    return existed;
+  }
   async startTurn(input) {
     const session = await this.readSession(input.providerSessionId);
     const providerTurnId = `e2e-turn-${session.turns.length + 1}`;
@@ -16369,7 +16620,7 @@ function deferLargeHistoryItemDetails(turn, deferredDetails) {
   };
 }
 function shouldPersistLiveHistoryItem(item) {
-  return item.kind === "commandExecution" || item.kind === "fileChange" || item.kind === "fileRead" || item.kind === "hook" || item.kind === "agentToolCall" || item.kind === "skillToolCall" || item.kind === "toolCall" || item.kind === "webSearch";
+  return item.kind === "commandExecution" || item.kind === "fileChange" || item.kind === "fileRead" || item.kind === "hook" || item.kind === "agentToolCall" || item.kind === "skillToolCall" || item.kind === "toolCall" || item.kind === "reasoning" || item.kind === "webSearch";
 }
 function shouldPersistFinalHistoryItem(item) {
   return item.kind === "agentMessage" || shouldPersistLiveHistoryItem(item);
@@ -17419,7 +17670,7 @@ var ThreadRuntimeEventProjector = class {
           const sequence = liveState.recordTurnItemOrder(record.id, turnId, item.id);
           const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
           const orderedLiveItem = {
-            ...withHistoryItemCreatedAt(item, eventTimestamp),
+            ...withHistoryItemCreatedAt2(item, eventTimestamp),
             sequence
           };
           const transportLiveItem = deferHistoryItemDetailForTransport(orderedLiveItem);
@@ -17470,7 +17721,7 @@ var ThreadRuntimeEventProjector = class {
         }
         const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
         const liveItem = {
-          ...withHistoryItemCreatedAt(event.item, eventTimestamp),
+          ...withHistoryItemCreatedAt2(event.item, eventTimestamp),
           sequence: liveState.recordTurnItemOrder(record.id, turnId, event.item.id)
         };
         const transportLiveItem = deferHistoryItemDetailForTransport(liveItem);
@@ -17503,7 +17754,7 @@ var ThreadRuntimeEventProjector = class {
         );
         const eventTimestamp = (/* @__PURE__ */ new Date()).toISOString();
         const orderedLiveItem = {
-          ...withHistoryItemCreatedAt(event.item, eventTimestamp),
+          ...withHistoryItemCreatedAt2(event.item, eventTimestamp),
           sequence
         };
         const transportLiveItem = deferHistoryItemDetailForTransport(orderedLiveItem);
@@ -17639,8 +17890,10 @@ var ThreadRuntimeEventProjector = class {
         }
         const turnId = liveState.displayTurnIdForRuntimeTurn(record.id, event.providerTurnId) ?? event.providerTurnId;
         updateThreadRecord(db, record.id, {
+          providerTurnId: null,
           status: "failed",
-          lastError: event.error
+          lastError: event.error,
+          lastTurnCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         liveState.setLivePlan(record.id, null);
         liveState.setLiveItems(record.id, null);
@@ -17676,7 +17929,7 @@ var ThreadRuntimeEventProjector = class {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
 };
-function withHistoryItemCreatedAt(item, createdAt) {
+function withHistoryItemCreatedAt2(item, createdAt) {
   return item.createdAt ? item : { ...item, createdAt };
 }
 
@@ -18120,7 +18373,11 @@ var ThreadDetailAssembler = class {
     if (input.record.providerTurnId && threadPatch.status === "idle" && activeLiveItems && activeLiveItems.items.length > 0) {
       threadPatch.status = "running";
     }
-    this.input.callbacks.updateThreadRecord(input.record.id, threadPatch);
+    const nextThreadPatch = {
+      ...threadPatch,
+      ...threadPatch.status !== "running" ? { providerTurnId: null } : {}
+    };
+    this.input.callbacks.updateThreadRecord(input.record.id, nextThreadPatch);
     const updated = this.input.callbacks.getUpdatedThreadRecord(input.record.id);
     this.input.callbacks.syncAfterRemoteSession(updated.id, remoteSession);
     const deferredDetails = /* @__PURE__ */ new Map();
@@ -18970,6 +19227,7 @@ function buildThreadPatch(remoteSession, model, reasoningEffort) {
   };
 }
 function toThreadDto(record, loadedIds, callbacks) {
+  const status = record.status ?? "idle";
   return {
     id: record.id,
     workspaceId: record.workspaceId,
@@ -18983,10 +19241,10 @@ function toThreadDto(record, loadedIds, callbacks) {
     collaborationMode: normalizeCollaborationMode(record.collaborationMode),
     approvalMode: record.approvalMode ?? "yolo",
     sandboxMode: normalizeSandboxMode(record.sandboxMode) ?? defaultSandboxModeForApprovalMode(record.approvalMode ?? "yolo"),
-    status: record.status ?? "idle",
+    status,
     summaryText: record.summaryText ?? null,
     lastError: record.lastError ?? null,
-    activeTurnId: record.providerTurnId ?? null,
+    activeTurnId: status === "running" ? record.providerTurnId ?? null : null,
     isLoaded: record.isConnected !== false && (record.providerSessionId ? loadedIds.has(record.providerSessionId) : false),
     isPinned: record.isPinned,
     createdAt: record.createdAt,